Should be the location of the experiment's align tiff folder, ex: \"C/desktop/work/image_processing/YYYYMMDD/align_tiffs\"\n resolution = {'res_xy_nm': 100, 'res_z_nm': 70} #Resolution of a pixel (do not alter)\n thresh = 0.9 #What qualifies for final probability map (do not alter)\n number_of_datasets = 20 #Number of wells in the experiemnts, \"20\" is an example where there are 16 samples and 4 controls\n\n #Rb Antibody\n conjugate_fn_str = 'GAD2' #String segment to search in a filename\n #conjugate_fn_str should be the term used in the name of the control align tiff for a well (usually \"PSD\", \"GAD2\", or \"SYNAPSIN\")\n target_fn_str = 'L106'\n #Ms Antibody project name, no parent or subclone number needed\n #target_fn_str should be the project number, for instance if this was testing L109 samples, this would be \"L109\"\n #Takes base directory string and gives you an array of all the files within\n filenames = aa.getListOfFolders(base_dir) #Do not change\n conjugate_filenames = [] #Do not change\n target_filenames = [] #Do not change\n query_list = [] #Do not change\n folder_names = [] #Do not change\n\n for n in range(1, 17):\n #Use if dataset missing\n #This is where you put in the rangee of wells used as your test samples\n #Since we have 16 samples that are test samples for L106, the range is equal to 1 through n+1, or 1 through 17\n #If your test samples do not begin at well 1, then adjust the beginning of the range accordingly (3 through 17 if the first test sample is in well 3) \n #continue\n\n print('Well: ', str(n)) #Do not change\n folder_names.append('Test-' + str(n)) # Collate 'dataset' names for excel sheet #Do not change\n conjugate_str = str(n) + '-' + conjugate_fn_str #creates filename to search for #Creates n-conjugatename #Do not change\n target_str = str(n) + '-' + target_fn_str #Do not change\n\n # Search for file associated with the specific dataset number\n indices = [i for i, s in enumerate(filenames) if conjugate_str == s[0:len(conjugate_str)]] #Do not change\n conjugate_name = filenames[indices[0]] #Do not change\n print(conjugate_name) #Do not change\n indices = [i for i, s in enumerate(filenames) if target_str == s[0:len(target_str)]] #Do not change\n target_name = filenames[indices[0]] #Do not change\n print(target_name) #Do not change\n \n conjugate_filenames.append(conjugate_name) #Do not change\n target_filenames.append(target_name) #Do not change\n\n # Create query\n #\n query = {'preIF': [conjugate_name], 'preIF_z': [2],\n 'postIF': [target_name], 'postIF_z': [1],\n 'punctumSize': 2}\n #preIF = items that are presynaptic targets go here, because GAD2, our conjugate, is presynaptic I put the conjugate_name in this box\n #preIF_z = how many tiffs a puncta must be in to be registered, conjugate sample number is 2 so 2 goes in this box\n #postIF = items that are postsynaptic targets go here, L106 is postsynaptic so I put target_name here\n #postIF_z = how many tiffs a puncta must be in to be registered, target sample number is 1 (for now unless changed later) \n #punctumSize = size of punctum the algorithm is looking for, do not change unless directed to\n\n \"\"\"Example of a presynaptic target and presynaptic conjugate\n query = {'preIF': [target_name,conjugate_name], 'preIF_z': [1,2],\n 'postIF': [], 'postIF_z': [],\n 'punctumSize': 2}\"\"\"\n\n \"\"\"Example of a postsynaptic target and presynaptic conjugate\n query = {'preIF': [conjugate_name], 'preIF_z': [2],\n 'postIF': [target_name], 'postIF_z': [1],\n 'punctumSize': 2}\"\"\"\n\n \"\"\"Example of a postsynaptic target and postsynaptic conjugate\n query = {'preIF': [], 'preIF_z': [],\n 'postIF': [target_name,conjugate_name], 'postIF_z': [1,2],\n 'punctumSize': 2}\"\"\"\n\n \"\"\"Example of a presynaptic target and postsynaptic conjugate\n query = {'preIF': [target_name], 'preIF_z': [1],\n 'postIF': [conjugate_name], 'postIF_z': [2],\n 'punctumSize': 2}\"\"\"\n\n\n query_list.append(query)\n\n\n #The following n samples are controls - you can add as many of these as you want by copying the block of code and pasting it after the last one\n #The notes in the following block of code apply to all of the controls\n n = 17 #well number of control sample\n folder_names.append('Control' + str(n)) # Collate 'dataset' names for excel sheet #Do not change\n reference_fn_str = 'GAD2' #String segment to search in a filename #refernce_fn_str is the project number/name of RB control\n target_fn_str = 'L106' #target_fn_str is the project number of the Ms control you are using\n conjugate_name, target_name = aa.findFilenames(reference_fn_str, target_fn_str, filenames, n) #Do not alter\n conjugate_filenames.append(conjugate_name) #Do not alter\n target_filenames.append(target_name) #Do not alter\n query = {'preIF': [conjugate_name], 'preIF_z': [2], 'postIF': [target_name], 'postIF_z': [1], 'punctumSize': 2} #Se the examples and explanations above about \"query\"\n query_list.append(query) #Do not change\n\n n = 18\n folder_names.append('Control' + str(n)) # Collate 'dataset' names for excel sheet\n reference_fn_str = 'GAD2' #String segment to search in a filename\n target_fn_str = 'SP2'\n conjugate_name, target_name = aa.findFilenames(reference_fn_str, target_fn_str, filenames, n)\n conjugate_filenames.append(conjugate_name)\n target_filenames.append(target_name)\n query = {'preIF': [target_name,conjugate_name], 'preIF_z': [1,2], 'postIF': [], 'postIF_z': [], 'punctumSize': 2}\n query_list.append(query)\n\n n = 19\n folder_names.append('Control' + str(n)) # Collate 'dataset' names for excel sheet\n reference_fn_str = 'NP-RB' #String segment to search in a filename\n target_fn_str = 'NP-MS'\n conjugate_name, target_name = aa.findFilenames(reference_fn_str, target_fn_str, filenames, n)\n conjugate_filenames.append(conjugate_name)\n target_filenames.append(target_name)\n query = {'preIF': [], 'preIF_z': [], 'postIF': [target_name,conjugate_name], 'postIF_z': [1,2], 'punctumSize': 2}\n query_list.append(query)\n\n n = 20\n folder_names.append('Control' + str(n)) # Collate 'dataset' names for excel sheet\n reference_fn_str = 'NPNS-RB' #String segment to search in a filename\n target_fn_str = 'NPNS-MS'\n conjugate_name, target_name = aa.findFilenames(reference_fn_str, target_fn_str, filenames, n)\n conjugate_filenames.append(conjugate_name)\n target_filenames.append(target_name)\n query = {'preIF': [], 'preIF_z': [], 'postIF': [target_name,conjugate_name], 'postIF_z': [1,2], 'punctumSize': 2}\n query_list.append(query)\n\n\n \n measure_list = aa.calculate_measure_lists(query_list, None, base_dir,\n thresh, resolution, target_filenames) # Run all the queries\n\n df = aa.create_df(measure_list, folder_names, target_filenames, conjugate_filenames) #Do not change\n print(df) #Do not change\n\n return df #Do not change","def create_test_set(self):\n test_files = os.listdir(self.image_folder_path)\n test_files = sorted_alphanumeric(test_files)\n delete_files(self.root_name, \"/VOC2021/ImageSets/Main\")\n write_txt(\"test.txt\", self.txt_path, test_files)","def gen_simple_test():\n count = 1\n mdict = {\n 'operating_frequency': 3e8,\n 'sample_rate': 8e3,\n 'signal': [1] * 5,\n 'origin_pos': [1000, 0, 0],\n 'dest_pos': [300, 200, 50],\n 'origin_vel': [0] * 3,\n 'dest_vel': [0] * 3,\n }\n io.savemat('{}{}_input'.format(tests_path, count), mdict)","def sample_replay_goal(self, obs):\n assert self._config.gc_input != 'state'\n random_batch = next(self._dataset)\n random_batch = self._wm.preprocess(random_batch)\n \n images = random_batch['image']\n states = random_batch['state']\n if self._config.labelled_env_multiplexing:\n assert obs['env_idx'].shape[0] == 1\n env_ids = random_batch['env_idx'][:, 0]\n if tf.reduce_any(env_ids == obs['env_idx']):\n ids = np.nonzero(env_ids == obs['env_idx'])[0]\n images = tf.gather(images, ids)\n states = tf.gather(states, ids)\n \n random_goals = tf.reshape(images, (-1,) + tuple(images.shape[2:]))\n random_goal_states = tf.reshape(states, (-1,) + tuple(states.shape[2:]))\n # random_goals = tf.random.shuffle(random_goals)\n return random_goals[:obs['image_goal'].shape[0]], random_goal_states[:obs['image_goal'].shape[0]]","def get_sample(self, index: int) -> Mapping[str, io.BytesIO]:\n del index\n if self._generated_image:\n return dict(images=self._generated_image)\n\n image_shape = (self._image_width, self._image_height, 3)\n array = np.uint8(np.random.rand(*image_shape) * 255)\n pil_image = Image.fromarray(array)\n image_io = io.BytesIO()\n pil_image.save(image_io, format=self._image_format)\n self._generated_image = image_io.getvalue()\n\n return dict(images=self._generated_image)","def generate(simulator, p, starts, goals, environment, r):\n num_gen_humans = min(len(starts), len(goals))\n print(\"Generating auto humans:\", num_gen_humans)\n from agents.humans.human_configs import HumanConfigs\n for i in range(num_gen_humans):\n start_config = generate_config_from_pos_3(starts[i])\n goal_config = generate_config_from_pos_3(goals[i])\n start_goal_configs = HumanConfigs(start_config, goal_config)\n human_i_name = \"auto_%04d\" % i\n # Generates a random human from the environment\n new_human_i = Human.generate_human_with_configs(\n start_goal_configs,\n generate_appearance=p.render_3D,\n name=human_i_name\n )\n # update renderer and get human traversible if it exists\n if p.render_3D:\n r.add_human(new_human_i)\n environment[\"human_traversible\"] = \\\n np.array(r.get_human_traversible())\n\n # Input human fields into simulator\n simulator.add_agent(new_human_i)","def generate_targets(self, data):\n\n assert isinstance(data, dict)\n\n image = data['image']\n polygons = data['polys']\n ignore_tags = data['ignore_tags']\n h, w, _ = image.shape\n\n polygon_masks = []\n polygon_masks_ignore = []\n for tag, polygon in zip(ignore_tags, polygons):\n if tag is True:\n polygon_masks_ignore.append(polygon)\n else:\n polygon_masks.append(polygon)\n\n gt_text_mask = self.generate_text_region_mask((h, w), polygon_masks)\n gt_mask = self.generate_effective_mask((h, w), polygon_masks_ignore)\n (center_lines, gt_center_region_mask, gt_top_height_map,\n gt_bot_height_map, gt_sin_map,\n gt_cos_map) = self.generate_center_mask_attrib_maps((h, w),\n polygon_masks)\n\n gt_comp_attribs = self.generate_comp_attribs(\n center_lines, gt_text_mask, gt_center_region_mask,\n gt_top_height_map, gt_bot_height_map, gt_sin_map, gt_cos_map)\n\n mapping = {\n 'gt_text_mask': gt_text_mask,\n 'gt_center_region_mask': gt_center_region_mask,\n 'gt_mask': gt_mask,\n 'gt_top_height_map': gt_top_height_map,\n 'gt_bot_height_map': gt_bot_height_map,\n 'gt_sin_map': gt_sin_map,\n 'gt_cos_map': gt_cos_map\n }\n\n data.update(mapping)\n data['gt_comp_attribs'] = gt_comp_attribs\n return data","def image_cli(\n caps_directory: str,\n modality: str,\n subjects_sessions_tsv: Optional[str] = None,\n use_uncropped_image: bool = False,\n acq_label: Optional[str] = None,\n suvr_reference_region: Optional[str] = None,\n custom_suffix: str = \"\",\n):\n parameters = get_parameters_dict(\n modality,\n \"image\",\n False,\n use_uncropped_image,\n custom_suffix,\n acq_label,\n suvr_reference_region,\n )\n DeepLearningPrepareData(\n caps_directory=caps_directory,\n tsv_file=subjects_sessions_tsv,\n parameters=parameters,\n )","def build_tiles(img,tilefile,tilesize,options=[]):\n\tlevels=ceil(log(max(img.get_xsize(),img.get_ysize())/tilesize)/log(2.0))\n\t\n\ttf=file(tilefile,\"w\")\n\t\n\ttile_dict={}\n\tpos=0\n\timg2=img.copy()\n\txs,ys=img2.get_xsize(),img2.get_ysize()\n\tfor l in range(int(levels)):\n\t\trmin=img2.get_attr(\"mean\")-img2.get_attr(\"sigma\")*3.0\n\t\trmax=img2.get_attr(\"mean\")+img2.get_attr(\"sigma\")*3.0\n\t\tfor x in range(0,img2.get_xsize(),tilesize):\n\t\t\tfor y in range(0,img2.get_ysize(),tilesize):\n\t\t\t\ti=img2.get_clip(Region(x,y,tilesize,tilesize))\n\t\t\t\ti.set_attr(\"render_min\",rmin)\n\t\t\t\ti.set_attr(\"render_max\",rmax)\n\t\t\t\ti.set_attr(\"jpeg_quality\",70)\n\t\t\t\tfsp=\"tmpimg.%d.%03d.%03d.jpg\"%(l,x/tilesize,y/tilesize)\n\t\t\t\ti.write_image(fsp)\n\t\t\t\tsz=os.stat(fsp).st_size\n\t\t\t\ttile_dict[(l,x/tilesize,y/tilesize)]=(pos,sz)\n\t\t\t\tpos+=sz\n\t\timg2.process_inplace(\"math.meanshrink\",{\"n\":2})\n\t\n\t# This will produce 2 power spectrum images in the tile file\n\t# with scale factors -1 and -2\n\tif \"pspec\" in options :\n\t\tnx,ny=img.get_xsize()/512,img.get_ysize()/512\n\t\ta=EMData()\n\t\ta.set_size(512,512)\n\t\tif (ny>2 and nx>2) :\n\t\t\tfor y in range(1,ny-1):\n\t\t\t\tfor x in range(1,nx-1):\n\t\t\t\t\tc=img.get_clip(Region(x*512,y*512,512,512))\n\t\t\t\t\tc.process_inplace(\"normalize\")\n\t\t\t\t\tc.process_inplace(\"math.realtofft\")\n\t\t\t\t\tc.process_inplace(\"math.squared\")\n\t\t\t\t\ta+=c\n\t\t\ta.set_value_at(256,256,0,.01)\n\t\t\ta-=a.get_attr(\"minimum\")-a.get_attr(\"sigma\")*.01\n\t\t\ta.process_inplace(\"math.log\")\n\t\t\ta-=a.get_attr(\"minimum\")\n\t\t\ta.set_attr(\"render_min\",a.get_attr(\"minimum\")-a.get_attr(\"sigma\")*.1)\n\t\t\ta.set_attr(\"render_max\",a.get_attr(\"mean\")+a.get_attr(\"sigma\")*4.0)\n\t\t\ta.set_attr(\"jepg_quality\",80)\n\t\t\ta.write_image(\"/tmp/tmpimg.mrc\")\n\t\t\tfsp=\"tmpimg.jpg\"\n\t\t\ta.write_image(fsp)\n\t\t\tsz=os.stat(fsp).st_size\n\t\t\ttile_dict[(-1,0,0)]=(pos,sz)\n\t\t\tpos+=sz\n\t\n#\t\ttry:\n\t\t\timport matplotlib\n\t\t\tmatplotlib.use('Agg')\n\t\t\timport pylab\n\t\t\tmanager = pylab.get_current_fig_manager()\n\t\t\tapix=options[\"pspec\"]\n\t\t\tdx=1.0/(2.0*apix*256.0)\n\t\t\tx=pylab.arange(dx,dx*255.9,dx)\n\t\t\ty=a.calc_radial_dist(255,1,1,0)\t# radial power spectrum (log)\n\t\t\tpylab.figure(figsize=(8,6),dpi=96)\n\t\t\tpylab.axes([.08,.08,.9,.9], axisbg='w')\n\t\t\tpylab.plot(x,y)\n\t\t\tpylab.axis([0,dx*256,min(y),max(y)])\n\t\t\tpylab.xlabel(\"Spatial Freq. (1/A)\")\n\t\t\tpylab.ylabel(\"Log Intensity (10^x)\")\n#\t\t\tprint y\n\t\t\t\n\t\t\tfsp=\"tmpimg2.png\"\n\t\t\tpylab.savefig(fsp,dpi=96)\n\t\t\tsz=os.stat(fsp).st_size\n\t\t\ttile_dict[(-2,0,0)]=(pos,sz)\n\t\t\tpos+=sz\n\n#\t\texcept:\n#\t\t\tprint \"Unable to generate plot (need matplotlib)\"\n\t\t\t\n\t\n\tpickle.dump(tile_dict,tf)\n\t\n\tfor l in range(int(levels)):\n\t\tfor x in range(0,xs,tilesize):\n\t\t\tfor y in range(0,ys,tilesize):\n\t\t\t\tfsp=\"tmpimg.%d.%03d.%03d.jpg\"%(l,x/tilesize,y/tilesize)\n\t\t\t\ta=file(fsp,\"r\")\n\t\t\t\tb=a.read()\n\t\t\t\ta.close()\n\t\t\t\ttf.write(b)\n\t\t\t\tos.remove(fsp)\n\t\txs/=2\n\t\tys/=2\n\t\n\tif \"pspec\" in options :\n\t\tfor fsp in [\"tmpimg.jpg\",\"tmpimg2.png\"] :\n\t\t\ta=file(fsp,\"r\")\n\t\t\tb=a.read()\n\t\t\ta.close()\n\t\t\ttf.write(b)\n#\t\t\tos.remove(fsp)\n\t\n\ttf.close()","def run_automatic_tester():\n number_of_target_maps = len(os.listdir(TargetDetectionTesterSettings.TARGET_DETECTION_REPORT_JSON_FILE_SAVE_PATH))\n overall_true_positive_count = 0\n overall_false_positive_count = 0\n overall_target_count = 0\n\n for index_0 in range(number_of_target_maps):\n\n answer_sheet = json.load(open(os.path.join(TargetDetectionTesterSettings.TARGET_MAP_ANSWER_SHEET_PATH, str(index_0 + 1) + \".json\")))\n answer_list = []\n\n for index_1 in range(len(answer_sheet[\"targets\"])):\n answer_list.append((answer_sheet[\"targets\"][index_1][\"target_center_coordinates\"][0], answer_sheet[\"targets\"][index_1][\"target_center_coordinates\"][1]))\n overall_target_count += len(answer_list)\n\n target_detection_result = json.load(open(os.path.join(TargetDetectionTesterSettings.TARGET_DETECTION_REPORT_JSON_FILE_SAVE_PATH, str(index_0 + 1) + \".json\")))\n result_list = []\n\n for index_2 in range(len(target_detection_result[\"image_processing_results\"])):\n result_list.append((target_detection_result[\"image_processing_results\"][index_2][\"target_location\"][0] + (target_detection_result[\"image_processing_results\"][index_2][\"target_location\"][2] / 2), target_detection_result[\"image_processing_results\"][index_2][\"target_location\"][1] + (target_detection_result[\"image_processing_results\"][index_2][\"target_location\"][3] / 2)))\n\n current_true_positive_count = 0\n current_false_positive_count = 0\n banned_index_list = []\n\n for index_3 in range(len(answer_list)):\n true_positive_found = False\n\n for index_4 in range(len(result_list)):\n is_index_4_banned = False\n\n for index_5 in range(len(banned_index_list)):\n if (index_4 == banned_index_list[index_5]):\n is_index_4_banned = True\n\n if (is_index_4_banned == True):\n continue\n\n correct_target_center_x = answer_list[index_3][0]\n correct_target_center_y = answer_list[index_3][1]\n\n detected_target_center_x = result_list[index_4][0]\n detected_target_center_y = result_list[index_4][1]\n\n if ((abs(correct_target_center_x - detected_target_center_x) <= 20) and (abs(correct_target_center_y - detected_target_center_y) <= 20)):\n current_true_positive_count += 1\n banned_index_list.append(index_4)\n true_positive_found = True\n continue\n\n current_false_positive_count = len(result_list) - current_true_positive_count\n\n overall_true_positive_count += current_true_positive_count\n overall_false_positive_count += current_false_positive_count\n\n percentage = 100 * float(overall_true_positive_count) / (overall_target_count)\n\n TargetDetectionTesterLogger.log(\"--------------------------------------------------\")\n TargetDetectionTesterLogger.log(\"Total True Positive Count: \" + str(overall_true_positive_count))\n TargetDetectionTesterLogger.log(\"Total False Positive Count: \" + str(overall_false_positive_count))\n TargetDetectionTesterLogger.log(\"Percentage of Successfully Detected Targets: \" + str(percentage) + \"%\")\n TargetDetectionTesterLogger.log(\"--------------------------------------------------\")","def generate_instance(num_facilities: int, num_towns: int, file_name: str) -> bool:\r\n\r\n facility_dictionary = [\r\n \"Perseus\",\r\n \"Andromeda\",\r\n \"Cassiopeia\",\r\n \"Cetus\",\r\n \"Cepheus\",\r\n \"Pegasus\",\r\n \"Auriga\",\r\n \"Hercules\",\r\n \"Sagitta\",\r\n \"Aquila\",\r\n \"Lyra\",\r\n \"Cygnus\",\r\n \"Hydra\",\r\n \"Crater\",\r\n \"Corvus\",\r\n \"Ophiuchus\",\r\n \"Serpens\",\r\n \"Centaurus\",\r\n \"Lupus\",\r\n \"Corona Australis\",\r\n \"Ara\",\r\n \"Orion\",\r\n \"Canis Major\",\r\n \"Canis Minor\",\r\n \"Lepus\",\r\n \"Monoceros\",\r\n \"Aries\",\r\n \"Taurus\",\r\n \"Gemini\",\r\n \"Cancer\",\r\n \"Leo\",\r\n \"Virgo\",\r\n \"Libra\",\r\n \"Scorpius\",\r\n \"Sagittarius\",\r\n \"Capricornus\",\r\n \"Aquarius\",\r\n \"Pisces\",\r\n \"Ursa Major\",\r\n \"Ursa Minor\",\r\n \"Draco\",\r\n \"Canes Venatici\",\r\n \"Boötes\",\r\n \"Corona Borealis\"\r\n ]\r\n towns_dictionary = [\r\n \"Rome\",\r\n \"Milan\",\r\n \"Naples\",\r\n \"Turin\",\r\n \"Florence\",\r\n \"Salerno\",\r\n \"Palermo\",\r\n \"Catania\",\r\n \"Genoa\",\r\n \"Bari\",\r\n \"Bologna\",\r\n \"Verona\",\r\n \"Pescara\",\r\n \"Cagliari\",\r\n \"Venice\",\r\n \"Messina\",\r\n \"Como\",\r\n \"Caserta\",\r\n \"Trieste\",\r\n \"Pisa\",\r\n \"Taranto\",\r\n \"Bergamo\",\r\n \"Reggio di Calabria\",\r\n \"Treviso\",\r\n \"Modena\",\r\n \"Parma\",\r\n \"Lecce\",\r\n \"Livorno\",\r\n \"Foggia\",\r\n \"Perugia\",\r\n \"Ravenna\",\r\n \"Ferrara\",\r\n \"Siracusa\",\r\n \"Sassari\",\r\n \"Udine\",\r\n \"Barletta\",\r\n \"Trento\",\r\n \"Brindisi\",\r\n \"Novara\",\r\n \"Ancona\",\r\n \"Soprabolzano\",\r\n \"Catanzaro\",\r\n \"Arezzo\",\r\n \"Marsala\",\r\n \"Asti\",\r\n \"Potenza\",\r\n \"Ragusa\",\r\n \"L’Aquila\",\r\n \"Benevento\",\r\n \"Civitavecchia\",\r\n \"Crotone\",\r\n \"Siena\",\r\n \"Campobasso\",\r\n \"Olbia\",\r\n \"Aosta\",\r\n \"Vibo Valentia\",\r\n \"Padova\",\r\n \"Savona\",\r\n \"Caltanissetta\",\r\n \"Vicenza\",\r\n \"Gorizia\",\r\n \"Rieti\",\r\n \"Grosseto\",\r\n \"Bolzano\",\r\n \"Massa\",\r\n \"Sanluri\",\r\n \"Latina\",\r\n \"Vercelli\",\r\n \"Belluno\",\r\n \"Cremona\",\r\n \"Oristano\",\r\n \"Mantova\",\r\n \"Prato\",\r\n \"Enna\",\r\n \"Lucca\",\r\n \"Viterbo\",\r\n \"Villacidro\",\r\n \"Trani\",\r\n \"Pavia\",\r\n \"Piacenza\",\r\n \"Monza\",\r\n \"Verbania\",\r\n \"Rimini\",\r\n \"Andria\",\r\n \"Fermo\",\r\n \"Nuoro\",\r\n \"Alessandria\",\r\n \"Matera\",\r\n \"Pistoia\",\r\n \"Reggio Emilia\",\r\n \"Frosinone\",\r\n \"Imperia\",\r\n \"Tortolì\",\r\n \"Iglesias\",\r\n \"Tempio Pausania\",\r\n \"Trapani\",\r\n \"Rovigo\",\r\n \"Teramo\",\r\n \"Sondrio\",\r\n \"Lanusei\",\r\n \"Biella\",\r\n \"Cosenza\",\r\n \"Cuneo\",\r\n \"Ascoli Piceno\",\r\n \"Avellino\",\r\n \"Chieti\",\r\n \"Terni\",\r\n \"Varese\",\r\n \"Forlì\",\r\n \"Lecco\",\r\n \"Carbonia\",\r\n \"Macerata\",\r\n \"La Spezia\",\r\n \"Pesaro\",\r\n \"Pordenone\",\r\n \"Lodi\",\r\n \"Brescia\",\r\n \"Agrigento\"\r\n ]\r\n\r\n if num_facilities > len(facility_dictionary) or num_towns > len(towns_dictionary):\r\n print(\"\\nToo many elements required:\")\r\n print(f\"\\tmax facilities: {len(facility_dictionary)}\")\r\n print(f\"\\tmax towns: {len(towns_dictionary)}\")\r\n return False\r\n\r\n if num_facilities < 1 or num_towns < 1:\r\n print(\"\\nFacility and towns elements must be more than 0\\n\")\r\n return False\r\n\r\n facilities = []\r\n towns = []\r\n hazards = []\r\n\r\n for i in range(num_facilities):\r\n facility = {\r\n \"facility_id\": i,\r\n \"name\": facility_dictionary[i],\r\n \"capacity\": math.floor(random.uniform(51, 300))\r\n }\r\n facilities.append(facility)\r\n\r\n for i in range(num_towns):\r\n town = {\r\n \"town_id\": i,\r\n \"name\": towns_dictionary[i],\r\n \"garbage\": math.floor(random.uniform(1, 50))\r\n }\r\n towns.append(town)\r\n\r\n for i in range(num_towns):\r\n town_hazards = []\r\n for j in range(num_facilities):\r\n town_hazards.append(math.floor(random.uniform(1, 100)))\r\n hazards.append(town_hazards)\r\n\r\n data = {\r\n \"towns\": towns,\r\n \"facilities\": facilities,\r\n \"hazards\": hazards\r\n }\r\n\r\n with open(f\"./instances/{file_name}.json\", 'w') as outfile:\r\n json.dump(data, outfile)\r\n\r\n return True","def trial_prep(self):\n pass","def make_random_tiles(sx=500, sy=500, sz=0, nb=50, noise_sigma=None,\n regular=True, double_pattern_y=False, double_pattern_z=False, \n assym_y=True, assym_z=True, return_image=False):\n \n if sz == 0:\n image = np.zeros((sy, sx))\n # to overcome an issue with odd nb:\n nb = int(np.ceil(nb / 2) * 2)\n \n if regular:\n x = np.linspace(start=0, stop=sx-1, num=nb, dtype=int)\n x = np.hstack((x[::2], x[1::2]))\n if assym_y:\n nb = nb*2\n y = np.linspace(start=0, stop=sy-1, num=nb, dtype=int)\n if double_pattern_y:\n y = np.hstack((y[::2], y[1::2]))\n x_id = np.tile(x, y.size//2)\n y_id = np.repeat(y, x.size//2)\n else:\n x_id = np.random.randint(sx, size=nb)\n y_id = np.random.randint(sy, size=nb)\n \n if noise_sigma is not None:\n x_id = x_id + np.random.normal(loc=0.0, scale=noise_sigma, size=x_id.size)\n x_id[x_id<0] = 0\n x_id[x_id>sx-1] = sx-1\n x_id = np.round(x_id).astype(int)\n y_id = y_id + np.random.normal(loc=0.0, scale=noise_sigma, size=y_id.size)\n y_id[y_id<0] = 0\n y_id[y_id>sy-1] = sy-1\n y_id = np.round(y_id).astype(int)\n \n coords = np.vstack((x_id, y_id)).T\n image[y_id, x_id] = 1\n masks = segmentation.watershed(-image)\n else:\n # make 3D simulation\n image = np.zeros((sz, sy, sx))\n # to overcome an issue with odd nb:\n nb = int(np.ceil(nb / 2) * 2)\n \n if regular:\n x = np.linspace(start=0, stop=sx-1, num=nb, dtype=int)\n x = np.hstack((x[::2], x[1::2]))\n if assym_y:\n nb_y = nb*2\n y = np.linspace(start=0, stop=sy-1, num=nb_y, dtype=int)\n if assym_z:\n nb_z = nb*2\n z = np.linspace(start=0, stop=sz-1, num=nb_z, dtype=int)\n if double_pattern_y:\n y = np.hstack((y[::2], y[1::2]))\n if double_pattern_z:\n z = np.hstack((z[::2], z[1::2]))\n x_id = np.tile(x, y.size//2)\n y_id = np.repeat(y, x.size//2)\n z_id = np.repeat(z, x.size//2)\n else:\n x_id = np.random.randint(sx, size=nb)\n y_id = np.random.randint(sy, size=nb)\n z_id = np.random.randint(sz, size=nb)\n \n if noise_sigma is None:\n print(\"For 3D simulations noise_sigma needs to be > 0\")\n print(\"Setting noise_sigma to 1\")\n noise_sigma = 1\n # x\n x_id = x_id + np.random.normal(loc=0.0, scale=noise_sigma, size=x_id.size)\n x_id[x_id<0] = 0\n x_id[x_id>sx-1] = sx-1\n x_id = np.round(x_id).astype(int)\n # y\n y_id = y_id + np.random.normal(loc=0.0, scale=noise_sigma, size=y_id.size)\n y_id[y_id<0] = 0\n y_id[y_id>sy-1] = sy-1\n y_id = np.round(y_id).astype(int)\n # z\n z_id = z_id + np.random.normal(loc=0.0, scale=noise_sigma, size=z_id.size)\n z_id[z_id<0] = 0\n z_id[z_id>sz-1] = sz-1\n z_id = np.round(z_id).astype(int)\n \n coords = np.vstack((x_id, y_id, z_id)).T\n image[z_id, y_id, x_id] = 1\n masks = segmentation.watershed(-image)\n\n if return_image:\n return coords, masks, image\n else:\n return coords, masks","def __generate_slices_a_set(self, set_id):\n image_set_path = os.path.join(self.__data_dir, set_id)\n os.chdir(image_set_path)\n try:\n os.mkdir(self.__new_dir_name)\n except FileExistsError:\n print('Directory already exist! Pass making new directory.')\n slice_dir = os.path.join(image_set_path, self.__new_dir_name)\n image_dir = os.path.join(image_set_path, 'normal')\n texts = os.listdir(image_dir)\n os.chdir(image_dir)\n for text in texts:\n if text.endswith('txt'):\n image_name = text.split('.')[0]\n # image_path = os.path.join(image_dir, '{}.jpg'.format(image_name))\n points = []\n count = 0\n with open(text, 'r') as f:\n for line in f.readlines():\n line = line.strip()\n points.append(line.split(' '))\n cv_image = cv2.imread(\"{}.jpg\".format(image_name))\n for point in points:\n count += 1\n x = int(point[0])\n y = int(point[1])\n a_slice = cv_image[\n x - self.__width:\n x + self.__width,\n y - self.__width:\n y + self.__width]\n new_dir = os.path.join(slice_dir, '{0}_p{1}.jpg'.format(image_name, count))\n cv2.imwrite(new_dir, a_slice)","def main():\n import shutil\n import json\n\n if not os.path.isdir(args.cache):\n # creation dossier cache\n os.mkdir(args.cache)\n\n if not os.path.exists(args.cache+'/overviews.json'):\n # creation fichier overviews.json a partir d'un fichier ressource\n shutil.copy2(args.overviews, args.cache+'/overviews.json')\n\n with open(args.cache+'/overviews.json') as json_overviews:\n overviews_dict = json.load(json_overviews)\n if not (\"list_OPI\" in overviews_dict):\n overviews_dict[\"list_OPI\"] = []\n\n out_raster_srs = gdal.osr.SpatialReference()\n out_raster_srs.ImportFromEPSG(overviews_dict['crs']['code'])\n conn_string = \"PG:host=\"+host+\" dbname=\"+database+\" user=\"+user+\" password=\"+password\n db_graph = gdal.OpenEx(conn_string, gdal.OF_VECTOR)\n if db_graph is None:\n raise ValueError(\"Connection to database failed\")\n list_filename = glob.glob(args.input)\n if verbose > 0:\n print(len(list_filename), \"fichier(s) a traiter\")\n\n try:\n with open(args.cache+'/cache_mtd.json', 'r') as inputfile:\n mtd = json.load(inputfile)\n except:\n mtd = {}\n\n cliche_dejaTraites = []\n for filename in list_filename:\n cliche = Path(filename).stem\n \n if (cliche in overviews_dict['list_OPI']):\n # OPI déja traitée\n cliche_dejaTraites.append(cliche)\n else:\n print('nouvelle image: ', filename)\n color = [randrange(255), randrange(255), randrange(255)]\n while (color[0] in mtd) and (color[1] in mtd[color[0]]) and (color[2] in mtd[color[0]][color[1]]):\n color = [randrange(255), randrange(255), randrange(255)]\n if color[0] not in mtd:\n mtd[color[0]] = {}\n if color[1] not in mtd[color[0]]:\n mtd[color[0]][color[1]] = {}\n mtd[color[0]][color[1]][color[2]] = cliche\n process_image(overviews_dict, db_graph, filename, color, out_raster_srs)\n # on ajout l'OPI traitée a la liste\n overviews_dict[\"list_OPI\"].append(cliche)\n\n with open(args.cache+'/cache_mtd.json', 'w') as outfile:\n json.dump(mtd, outfile)\n\n with open(args.cache+'/overviews.json', 'w') as outfile:\n json.dump(overviews_dict, outfile)\n\n print(\"\\n\", len(list_filename) - len(cliche_dejaTraites),\"/\",len(list_filename),\"OPI(s) ajoutée(s)\")\n if len(cliche_dejaTraites) > 0:\n print(cliche_dejaTraites, \"déjà traitées : OPI non recalculée(s)\")","def main():\n\ttile_dimensions = (512, 512)\n\ttile_count = (5, 4) \n\timage = Image.new(\"RGB\", (tile_dimensions[0] * tile_count[0], tile_dimensions[1] * tile_count[1]), None)\n\n\ttry:\n\t\turl = sys.argv[1]\n\texcept:\n\t\tprint \"Please enter a Google Maps URL as a parameter.\"\n\t\tprint \"Usage: $ python get_pano.py https://www.google.com/maps/@34.1027387,-118.340471,3a,75y,32.1h,87.53t/data=!3m7!1e1!3m5!1soInaTCic7TsAAAQDMaZ31A!2e0!3e2!7i13312!8i6656\"\n\t\treturn\n\n\ttry:\n\t\tprint \"************************************\"\n\t\tprint \"Fetching images from Google Maps, this could take some time...\"\n\t\tregex = re.compile(r'panoid\\=([^&]*)', re.I)\n\t\tpano_id = regex.findall(urllib.unquote(url))[0]\n\t\tfor y in range(tile_count[1]):\n\t\t\tfor x in range(tile_count[0]):\n\t\t\t\timg_url = \"https://geo2.ggpht.com/cbk?cb_client=maps_sv.tactile&authuser=0&hl=en&panoid=\" + pano_id + \"&output=tile&x=\"+str(x)+\"&y=\"+str(y)+\"&zoom=3&nbt&fover=2\"\n\t\t\t\tresponse = urllib2.urlopen(img_url)\n\t\t\t\tfile_data = StringIO(response.read())\n\t\t\t\timage.paste(Image.open(file_data), (x * tile_dimensions[0], y * tile_dimensions[1]))\n\t\t\n\t\tfilename = \"pano-\" + pano_id + \".jpg\"\n\t\timage.save(filename)\n\t\tprint \"Success, image saved as \\033[96m\" + filename + \"\\033[00m\"\n\t\tprint \"************************************\"\n\n\n\texcept Exception as e:\n\t\tprint \"Sorry something broke.\"\n\t\tprint e","def sample_trajectories(env_teacher, env_student, policy_teacher, policy_student, min_timesteps_per_batch, max_path_length, render=False, render_mode=('rgb_array')):\n\n # TODO: GETTHIS from HW1\n timesteps_this_batch = 0\n paths_t, paths_s = [], []\n while timesteps_this_batch < min_timesteps_per_batch:\n path_teacher, path_student = sample_trajectory(env_teacher, env_student, policy_teacher, policy_student, max_path_length, render, render_mode)\n paths_t.append(path_teacher)\n paths_s.append(path_student)\n timesteps_this_batch += get_pathlength(path_teacher) + get_pathlength(path_student)\n\n #print(\"OBS\")\n #print([p[\"observation\"].shape for p in paths_s])\n return paths_t, paths_s, timesteps_this_batch","def generate_one(self, n_images, min_correct=None, p_correct=0.5, n_correct=None, n_caps_per_image=1, configs=None):\n random.seed() # For multiprocessing (TODO: can we avoid this?)\n imgs = np.zeros((n_images, 3, c.DIM, c.DIM), dtype=np.uint8)\n labels = np.zeros((n_images, ), dtype=np.uint8)\n if configs is not None:\n cfg_idx = random.choice(len(configs))\n target_cfg = configs[cfg_idx]\n else:\n # FIXME: Make this OOP to avoid these if statements\n if self.img_type == 'spatial':\n target_cfg = self.random_config_spatial()\n elif self.img_type == 'single':\n target_cfg = self.random_config_single()\n\n if self.data_type == 'concept':\n if n_correct is not None:\n # Fixed number of targets and distractors\n n_target = n_correct\n n_distract = n_images - n_target\n elif min_correct is not None:\n # Minimum number of targets, otherwise sample whatever\n # TODO: combine min_correct and min_incorrect\n n_target = min_correct\n n_distract = 0\n else:\n # Minimum of 2 targets and distractors each\n n_target = 2\n n_distract = 2\n else:\n n_target = 1\n n_distract = n_images # Never run out of distractors\n\n cfgs = []\n shapes = []\n cfgs_to_cap = []\n for i in range(n_images):\n if n_target > 0:\n label = 1\n n_target -= 1\n elif n_distract > 0:\n label = 0\n n_distract -= 1\n else:\n label = (random.random() < p_correct)\n\n if self.img_type == 'spatial':\n new_cfg, new_shapes, cfg_to_cap = self.generate_spatial(target_cfg, label, n_caps_per_image)\n elif self.img_type == 'single':\n new_cfg, new_shapes = self.generate_single(target_cfg, label)\n\n # Create image and draw shapes\n img = self.create_image(new_shapes)\n imgs[i] = img\n labels[i] = label\n cfgs.append(new_cfg)\n shapes.append(new_shapes)\n cfgs_to_cap.append(cfg_to_cap)\n\n return imgs, labels, target_cfg, cfgs, cfgs_to_cap, shapes","def new_robot_images(images): #py:new_robot_images\n RUR._new_robot_images_(images)","def training_data_generation(DATA_DIR, img_height_size, img_width_size, label_list):\r\n \r\n img_ms_files = glob.glob(DATA_DIR + '\\\\Train_MS' + '\\\\Train_*.tif')\r\n img_pan_files = glob.glob(DATA_DIR + '\\\\Train_Pan' + '\\\\Train_*.tif')\r\n polygon_files = glob.glob(DATA_DIR + '\\\\Train_Polygons' + '\\\\Train_*.geojson')\r\n \r\n img_ms_array_list = []\r\n img_pan_array_list = []\r\n mask_array_list = []\r\n \r\n for file in range(len(img_ms_files)):\r\n with rasterio.open(img_ms_files[file]) as f:\r\n metadata = f.profile\r\n img_ms = np.transpose(f.read(tuple(np.arange(metadata['count']) + 1)), [1, 2, 0])\r\n \r\n with rasterio.open(img_pan_files[file]) as g:\r\n metadata_pan = g.profile\r\n img_pan = np.expand_dims(g.read(1), axis = 2)\r\n \r\n ms_to_pan_ratio = metadata['transform'][0] / metadata_pan['transform'][0]\r\n \r\n if (img_height_size % ms_to_pan_ratio) != 0 or (img_width_size % ms_to_pan_ratio) != 0:\r\n raise ValueError('Please make sure that both img_height_size and img_width_size can be divided by {}'.format(int(ms_to_pan_ratio)))\r\n \r\n mask = training_mask_generation(img_pan_files[file], polygon_files[file], labels = label_list)\r\n \r\n img_ms_array, img_pan_array, mask_array = image_clip_to_segment_and_convert(img_ms, img_pan, mask, ms_to_pan_ratio, \r\n img_height_size, img_width_size)\r\n \r\n img_ms_array_list.append(img_ms_array)\r\n img_pan_array_list.append(img_pan_array)\r\n mask_array_list.append(mask_array)\r\n \r\n img_ms_full_array = np.concatenate(img_ms_array_list, axis = 0)\r\n img_pan_full_array = np.concatenate(img_pan_array_list, axis = 0)\r\n mask_full_array = to_categorical(np.concatenate(mask_array_list, axis = 0), num_classes = len(label_list))\r\n \r\n return img_ms_full_array, img_pan_full_array, mask_full_array","def tst_random_set():\n final_wave, final_spec, final_z = desi_qso_templates(\n outfil='test_random_set.fits', N_perz=100, seed=12345)","def run_experiments() :\n #%%\n target_size=(32,32)\n g_specs = {\n \"batch_size\" : [ 30 , 60, 100 ],\n \"learning_rate\" : [ 0.0002, 0.0003, 0.0005 ],\n \"drop_out_rate\" : [ 0.2, 0.25, 0.3 ],\n \"rescale_mode\" : [ \"max_q\" , \"max\", \"\" ]\n }\n\n model_traits = MODEL_TRAITS[\"model2\"].copy()\n tt_obj = model_traits[\"trainer_tester_class\"]( model_traits )\n del model_traits[\"trainer_tester_class\"]\n\n cnt = 0\n for batchs, lrate, do_rate, resc_mode in product( g_specs[\"batch_size\"],\n g_specs[\"learning_rate\"],\n g_specs[\"drop_out_rate\"],\n g_specs[\"rescale_mode\"] ) :\n\n tt_obj.model_traits.update( {\"batch_size\" : batchs,\n \"learning_rate\" : lrate,\n \"rescale_mode\" : resc_mode,\n \"drop_out_rate\" : do_rate } )\n\n train_4d, train_gt = tu.make_4d_arrays( images_dir=\"images/train\",\n target_size=target_size )\n\n test_4d, test_gt = tu.make_4d_arrays( images_dir=\"images/test\",\n target_size=target_size )\n\n data = {\"train_4d\" : train_4d,\n \"test_4d\" : test_4d,\n \"train_y\" : train_gt,\n \"test_y\" : test_gt}\n\n valid_accu_log, train_accu_log = tt_obj.train( model_traits, data,\n logl=100 )\n idx_v = int(np.argmax( valid_accu_log))\n idx_t = int(np.argmax( train_accu_log))\n\n model_traits.update({\"valid_accu_log\" : valid_accu_log,\n \"train_accu_log\" : train_accu_log,\n \"best_valid\" : max(valid_accu_log),\n \"best_valid_at\" : idx_v,\n \"train_at_best_valid\" : train_accu_log[idx_v],\n \"best_train\" : max(train_accu_log),\n \"best_train_at\": idx_t })\n\n #print(cnt, pformat(model_traits) )\n print( \"%d : best_train = %.4f, best_valid = %.4f\" % \\\n (cnt, max(train_accu_log), max(valid_accu_log) ))\n\n with open( \"exp_results_%d.json\" % cnt,\n \"wt\" , encoding=\"utf8\" ) as f_out :\n print( json.dumps( model_traits ), file=f_out)\n\n\n cnt += 1\n #%%","def trial_table():\n # Read data\n included = read_npy_file('trials.included.npy')\n fb_type = read_npy_file('trials.feedbackType.npy')\n fb_type = fb_type.astype(int)\n fb_time = read_npy_file('trials.feedback_times.npy')\n go_cue = read_npy_file('trials.goCue_times.npy')\n trial_intervals = read_npy_file('trials.intervals.npy')\n rep_num = read_npy_file('trials.repNum.npy')\n response_choice = read_npy_file('trials.response_choice.npy')\n response_times = read_npy_file('trials.response_times.npy')\n visual_left = read_npy_file('trials.visualStim_contrastLeft.npy')\n visual_right = read_npy_file('trials.visualStim_contrastRight.npy')\n visual_times = read_npy_file('trials.visualStim_times.npy')\n\n for j in range(len(trial_intervals)):\n nwb_file.add_trial(trial_intervals[j, 0], trial_intervals[j, 1])\n\n nwb_file.add_trial_column(\n 'included',\n 'Importantly, while this variable gives inclusion criteria according '\n 'to the definition of disengagement (see manuscript Methods), it does '\n 'not give inclusion criteria based on the time of response, as used '\n 'for most analyses in the paper.',\n np.ravel(included)\n )\n nwb_file.add_trial_column(\n 'go_cue',\n 'The \\'goCue\\' is referred to as the \\'auditory tone cue\\' in the manuscript.',\n np.ravel(go_cue)\n )\n nwb_file.add_trial_column(\n 'visual_stimulus_time',\n 'Times are relative to the same time base as every other time in the dataset, '\n 'not to the start of the trial.',\n np.ravel(visual_times)\n )\n nwb_file.add_trial_column(\n 'visual_stimulus_left_contrast',\n 'Proportion contrast. A value of 0.5 means 50% contrast. 0 is a blank '\n 'screen: no change to any pixel values on that side (completely undetectable).',\n np.ravel(visual_left)\n )\n nwb_file.add_trial_column(\n 'visual_stimulus_right_contrast',\n 'Proportion contrast. A value of 0.5 means 50% contrast. 0 is a blank '\n 'screen: no change to any pixel values on that side (completely undetectable).',\n np.ravel(visual_right)\n )\n nwb_file.add_trial_column(\n 'response_time',\n 'Times are relative to the same time base as every other time in the dataset, '\n 'not to the start of the trial.',\n np.ravel(response_times)\n )\n nwb_file.add_trial_column(\n 'response_choice',\n 'Enumerated type. The response registered at the end of the trial, '\n 'which determines the feedback according to the contrast condition. '\n 'Note that in a small percentage of cases (~4%, see manuscript Methods) '\n 'the initial wheel turn was in the opposite direction. -1 for Right '\n 'choice (i.e. correct when stimuli are on the right); +1 for left '\n 'choice; 0 for Nogo choice.',\n np.ravel(response_choice)\n )\n nwb_file.add_trial_column(\n 'feedback_time',\n 'Times are relative to the same time base as every other time in the dataset, '\n 'not to the start of the trial.',\n np.ravel(fb_time)\n )\n nwb_file.add_trial_column(\n 'feedback_type',\n 'Enumerated type. -1 for negative feedback (white noise burst); +1 for '\n 'positive feedback (water reward delivery).',\n np.ravel(fb_type)\n )\n nwb_file.add_trial_column(\n 'rep_num',\n 'Trials are repeated if they are \"easy\" trials (high contrast stimuli '\n 'with large difference between the two sides, or the blank screen '\n 'condition) and this keeps track of how many times the current '\n 'trial\\'s condition has been repeated.',\n np.ravel(rep_num)\n )","def three_sample_images():\n samples = samples_path()\n _truck = np.array(Image.open(os.path.join(samples, \"truck.png\")))\n _deer = np.array(Image.open(os.path.join(samples, \"deer.png\")))\n _frog = np.array(Image.open(os.path.join(samples, \"frog.png\")))\n truck = transforms.ToTensor()(_truck)\n deer = transforms.ToTensor()(_deer)\n frog = transforms.ToTensor()(_frog)\n return torch.stack([truck, deer, frog])","def prep_synthetic_test(self, outdir='synthetic_test',\n loc=(300,350,50,100), #t89\n signal='linear', #sinusoidal, exponential?\n rate=0.01, #(m)\n noise=None, #white, colored (correlated)?\n ramp=None): #linear, quadratic?\n if os.path.isdir(outdir):\n shutil.rmtree(outdir)\n os.mkdir(outdir)\n\n shape = self.Set.Shape\n ind_signal = np.zeros(shape, dtype='bool')\n ind_signal[loc[0]:loc[1],loc[2]:loc[3]] = 1\n bd = 20\n ind_bound = np.zeros_like(ind_signal)\n ind_bound[loc[0]-bd:loc[1]+bd,loc[2]-bd:loc[3]+bd] = 1\n ind_bound[ind_signal] = 0\n\n for ig in self.Set:\n amp, phs = roipy.tools.load_bil(ig)\n\n # Create synthetic signal\n phs_syn = np.zeros_like(phs)\n phs_syn[ind_signal] = (rate * ig.Timespan)\n\n # Create transition zone\n phs_syn[ind_bound] = (0.01 * ig.Timespan)\n\n # Add noise\n if noise != None:\n noise = add_noise(noise)\n phs_syn += noise\n\n # Add ramps\n if ramp != None:\n surface = make_surface(ramp)\n phs_syn += surface\n\n # Save Data & Rsc\n phs_syn = phs_syn * (4*np.pi/ig.Wavelength) #convert to phase\n outpath = os.path.join(outdir,ig.Name.replace('rect_','rect_synthetic_'))\n roipy.tools.save_bil(ig, outpath, amp, phs_syn)\n #roipy.tools.save_rsc(ig.Rsc, outpath + '.rsc') #automatically called\n\n print('synthetic test set up in:\\n{}'.format(os.path.abspath(outdir)))","def fully_sample_sky(region = \"allsky\", limitregion = False, adaptivep0 = True, useprior = \"RHTPrior\", velrangestring = \"-10_10\", \n gausssmooth_prior = False, tol=1E-5, sampletype = \"mean_bayes\", mcmc=False, deltafuncprior=False, testpsiproj=False, \n testthetas=False, save=True, baseprioramp = 1E-8, smoothprior=False, sig=30, fixwidth=False):\n \n print(\"Fully sampling sky with options: region = {}, limitregion = {}, useprior = {}, velrangestring = {}, gausssmooth_prior = {}, deltafuncprior = {}, testpsiproj = {}, testthetas = {}\".format(region, limitregion, useprior, velrangestring, gausssmooth_prior, deltafuncprior, testpsiproj, testthetas))\n\n out_root = \"/disks/jansky/a/users/goldston/susan/Wide_maps/\"\n\n # Get ids of all pixels that contain RHT data\n rht_cursor, tablename = get_rht_cursor(region = region, velrangestring = velrangestring)\n print(\"table name is\", tablename)\n all_ids = get_all_rht_ids(rht_cursor, tablename)\n \n if limitregion is True:\n print(\"Loading all allsky data points that are in the SC_241 region\")\n # Get all ids that are in both allsky data and SC_241\n all_ids_SC = pickle.load(open(\"SC_241_healpix_ids.p\", \"rb\"))\n all_ids = list(set(all_ids).intersection(all_ids_SC))\n \n print(\"beginning creation of all posteriors\")\n \n if testthetas is False:\n # Create and sample posteriors for all pixels\n if useprior is \"RHTPrior\":\n all_pMB, all_psiMB = sample_all_rht_points(all_ids, adaptivep0 = adaptivep0, rht_cursor = rht_cursor, region = region, useprior = useprior, gausssmooth_prior = gausssmooth_prior, tol=tol, sampletype = sampletype, mcmc = mcmc, deltafuncprior=deltafuncprior, testpsiproj=testpsiproj, baseprioramp=baseprioramp)\n elif useprior is \"ThetaRHT\":\n all_pMB, all_psiMB = sample_all_rht_points_ThetaRHTPrior(all_ids, adaptivep0 = adaptivep0, region = region, useprior = useprior, local = False, tol=tol, smoothprior=smoothprior, sig=sig, fixwidth=fixwidth)\n \n # Place into healpix map\n hp_psiMB = make_hp_map(all_psiMB, all_ids, Nside = 2048, nest = True)\n hp_pMB = make_hp_map(all_pMB, all_ids, Nside = 2048, nest = True)\n \n if limitregion is False:\n psiMB_out_fn = \"psiMB_allsky_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\".fits\"\n pMB_out_fn = \"pMB_allsky_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\".fits\"\n elif limitregion is True:\n if mcmc is True:\n psiMB_out_fn = \"psiMB_DR2_SC_241_mcmc_50_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_tol_{}.fits\".format(tol)\n pMB_out_fn = \"pMB_DR2_SC_241_mcmc_50_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_tol_{}.fits\".format(tol)\n else:\n if sampletype is \"mean_bayes\":\n print(\"saving mean bayes sampled planck+rht data\")\n #psiMB_out_fn = \"psiMB_DR2_SC_241_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_tol_{}.fits\".format(tol)\n #pMB_out_fn = \"pMB_DR2_SC_241_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_tol_{}.fits\".format(tol)\n #psiMB_out_fn = \"psiMB_DR2_SC_241_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_deltafuncprior_\"+str(deltafuncprior)+\"_fixedpsi0_reverseRHT.fits\"\n #pMB_out_fn = \"pMB_DR2_SC_241_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_deltafuncprior_\"+str(deltafuncprior)+\"_fixedpsi0_reverseRHT.fits\"\n if useprior is \"RHTPrior\":\n psiMB_out_fn = \"psiMB_DR2_SC_241_prior_\"+useprior+\"_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_deltafuncprior_\"+str(deltafuncprior)+\"_baseprioramp_\"+str(baseprioramp)+\".fits\"\n pMB_out_fn = \"pMB_DR2_SC_241_prior_\"+useprior+\"_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_deltafuncprior_\"+str(deltafuncprior)+\"_baseprioramp_\"+str(baseprioramp)+\".fits\"\n elif useprior is \"ThetaRHT\":\n psiMB_out_fn = \"psiMB_DR2_SC_241_prior_\"+useprior+\"_\"+velrangestring+\"_smoothprior_\"+str(smoothprior)+\"_sig_\"+str(sig)+\"_adaptivep0_\"+str(adaptivep0)+\"_fixwidth_\"+str(fixwidth)+\".fits\"\n pMB_out_fn = \"pMB_DR2_SC_241_prior_\"+useprior+\"_\"+velrangestring+\"_smoothprior_\"+str(smoothprior)+\"_sig_\"+str(sig)+\"_adaptivep0_\"+str(adaptivep0)+\"_fixwidth_\"+str(fixwidth)+\".fits\"\n \n \n elif sampletype is \"MAP\":\n psiMB_out_fn = \"psiMB_MAP_DR2_SC_241_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_baseprioramp_\"+str(baseprioramp)+\".fits\"\n pMB_out_fn = \"pMB_MAP_DR2_SC_241_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_baseprioramp_\"+str(baseprioramp)+\".fits\"\n \n if testpsiproj is True:\n psiMB_out_fn = \"psiMB_DR2_SC_241_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_deltafuncprior_\"+str(deltafuncprior)+\"_testpsiproj_\"+str(testpsiproj)+\"_smalloffset.fits\"\n pMB_out_fn = \"pMB_DR2_SC_241_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_deltafuncprior_\"+str(deltafuncprior)+\"_testpsiproj_\"+str(testpsiproj)+\"_smalloffset.fits\"\n \n if save:\n hp.fitsfunc.write_map(out_root + psiMB_out_fn, hp_psiMB, coord = \"G\", nest = True) \n hp.fitsfunc.write_map(out_root + pMB_out_fn, hp_pMB, coord = \"G\", nest = True) \n else:\n all_maxrhts, zzz = sample_all_rht_points(all_ids, adaptivep0 = adaptivep0, rht_cursor = rht_cursor, region = region, useprior = useprior, gausssmooth_prior = gausssmooth_prior, tol=tol, sampletype = sampletype, mcmc = mcmc, deltafuncprior=deltafuncprior, testpsiproj=testpsiproj, testthetas=testthetas)\n maxrhts = make_hp_map(all_maxrhts, all_ids, Nside = 2048, nest = True)\n hp.fitsfunc.write_map(out_root + \"vel_\" + velrangestring +\"_maxrht.fits\", maxrhts, coord = \"G\", nest = True)","def load_tamper(self, dataset_dir, subset):\n # Add classes. We have one class.\n # Naming the dataset nucleus, and the class nucleus\n self.add_class(\"tampers\", 1, \"tampers\")\n\n # Which subset?\n # \"val\": use hard-coded list above\n # \"train\": use data from stage1_train minus the hard-coded list above\n # else: use the data from the specified sub-directory\n # assert subset in [\"train\", \"val\", \"stage1_train\", \"stage1_test\", \"stage2_test\"]\n # subset_dir = \"stage1_train\" if subset in [\"train\", \"val\"] else subset\n dataset_dir = os.path.join(dataset_dir, subset, 'images')\n if subset == \"val\" or subset == \"test\":\n image_ids = next(os.walk(dataset_dir))[2]\n else:\n # Get image ids from directory names\n image_ids = next(os.walk(dataset_dir))[2]\n \n\n # dircopy_move = '/data/twj/copy-move/data_zoo/dataset/images/train'\n # image_ids_copy_move = next(os.walk(os.path.join(dircopy_move, 'images')))[2]\n\n # dirnew_splicing = '/data/tamper'\n # image_ids_new_splicing = next(os.walk(os.path.join(dirnew_splicing, 'images')))[2]\n\n # dircopy_move = '/home/as/deeplab/wpmrcnn/ca2new/test'\n # image_ids_copy_move = next(os.walk(os.path.join(dircopy_move, 'images')))[2]\n\n \n # dircopy_move = '/data/gy/ca2att/train3'\n # image_ids_copy_move = next(os.walk(os.path.join(dircopy_move, 'images')))[2]\n\n # # # dirtxt_sp = '/data/gy/tamperpre/train'\n # # # image_ids_txt_sp = next(os.walk(os.path.join(dirtxt_sp, 'images')))[2]\n\n # dirnew_sp = '/data/gy/c2newsp/train'\n # image_ids_new_sp = next(os.walk(os.path.join(dirnew_sp, 'images')))[2]\n\n # Add images\n for image_id in image_ids:\n self.add_image(\n \"tampers\",\n image_id=image_id[:-4],\n path=os.path.join(dataset_dir, image_id))\n\n # for image_id in image_ids_copy_move:\n # self.add_image(\n # \"tampers\",\n # image_id=image_id[:-4],\n # path=os.path.join(dircopy_move, 'images', image_id))\n\n # for image_id in image_ids_new_splicing:\n # self.add_image(\n # \"tampers\",\n # image_id=image_id[:-4],\n # path=os.path.join(dirnew_splicing, 'images', image_id))\n\n # # for image_id in image_ids_txt_sp:\n # # self.add_image(\n # # \"tampers\",\n # # image_id=image_id[:-4],\n # # path=os.path.join(dirtxt_sp, 'images', image_id))\n\n # for image_id in image_ids_new_sp:\n # self.add_image(\n # \"tampers\",\n # image_id=image_id[:-4],\n # path=os.path.join(dirnew_sp, 'images', image_id))","def generate_tfrecords(image_dirs, resize_str, params, num_samples_per_rec=20):\n print('Image folders:', image_dirs)\n\n # Iterate over image folders, processing each.\n cam = params.camera\n for image_dir in image_dirs:\n print('Processing folder %s' % image_dir)\n # Get data params, set new ones.\n _, _, num_kp, cam_orig = utils.read_data_params(\n os.path.join(image_dir, 'data_params.pbtxt'))\n cam.baseline = cam_orig.baseline\n params.num_kp = num_kp\n out_dir = os.path.join(image_dir, resize_str)\n os.makedirs(out_dir, exist_ok=True)\n utils.write_to_text_file(os.path.join(out_dir, 'data_params.pbtxt'), params)\n\n # Read image files and generate tfrecords.\n filenames_left = glob.glob(os.path.join(image_dir, '*_L.png'))\n filenames_right = glob.glob(os.path.join(image_dir, '*_R.png'))\n filenames_target_left = glob.glob(os.path.join(image_dir, '*_L.pbtxt'))\n filenames_target_right = glob.glob(os.path.join(image_dir, '*_R.pbtxt'))\n if not filenames_right:\n filenames_right = filenames_left\n filenames_target_right = filenames_target_left\n else:\n print('Have stereo images')\n assert len(filenames_left) == len(filenames_target_left)\n assert len(filenames_target_left) == len(filenames_target_right)\n assert len(filenames_left) == len(filenames_right)\n filenames_left.sort()\n filenames_right.sort()\n filenames_target_left.sort()\n filenames_target_right.sort()\n total = len(filenames_left)\n print('Found %d total image examples' % total)\n\n j = 0\n while j < total:\n jj = min(total, j + num_samples_per_rec)\n record_name = ('%04d' % j) + '.tfrecord'\n print('Record file %s' % record_name)\n path = os.path.join(out_dir, record_name)\n print('Generating examples %d to %d' % (j, jj))\n generate(path, cam_orig, cam, filenames_left[j:jj], filenames_right[j:jj],\n filenames_target_left[j:jj], filenames_target_right[j:jj])\n j = jj","def getGoogleMap(self, lat, lng, wTileN, hTileN, zoom):\n start_x, start_y = self.getStartTlXY(lat, lng, zoom)\n width, height = 256 * wTileN, 256 * hTileN\n map_img = Image.new('RGB', (width, height))\n for x in range(0, wTileN):\n for y in range(0, hTileN):\n url = 'https://mt0.google.com/vt?x=' + \\\n str(start_x+x)+'&y='+str(start_y+y)+'&z='+str(zoom)\n current_tile = str(x)+'-'+str(y)\n urllib.request.urlretrieve(url, current_tile)\n map_img.paste(Image.open(current_tile), (x*256, y*256))\n os.remove(current_tile)\n return map_img"],"string":"[\n \"def stim_generate(params,stim_list,train):\\n if train:\\n stim = list(stim_list.keys())\\n shuffled_stim = shuffled_images = []\\n #for each run get equal amounts of stim and shuffle\\n #can only work if 'trials_per_run' is divisible by number of stims\\n for run in range(params['runs']):\\n temp_list = stim * int(params['trials_per_run']/len(stim))\\n random.shuffle(temp_list)\\n shuffled_stim = shuffled_stim + temp_list\\n for stim in shuffled_stim:\\n shuffled_images.append(stim_list[stim])\\n else:\\n #open the test stim images\\n images = []\\n for each in os.listdir(stim_list):\\n if '.DS_Store' not in each:\\n img = os.path.join(stim_list,each)\\n images.append([img,img])\\n\\n #randomize images\\n random.shuffle(images)\\n\\n #split images into matches and not matches\\n matches,not_matches = images[:len(images)//2],images[len(images)//2:]\\n\\n #shift the image list so that the pictures dont match\\n not_matches = shift_list(not_matches)\\n\\n #combine matches and not matches and randomize order\\n shuffled_images = matches + not_matches\\n random.shuffle(shuffled_images)\\n\\n #get category labels\\n shuffled_stim = []\\n for img in shuffled_images:\\n if img[0] == img[1]:\\n shuffled_stim.append(\\\"match\\\")\\n else:\\n shuffled_stim.append(\\\"not match\\\")\\n\\n return(shuffled_stim,shuffled_images)\",\n \"def create_sets(\\n path: tuple,\\n maps_ath: str,\\n gt_maps_path: str,\\n ds_index: int = 0,\\n skip_black: bool = True,\\n skip_water: bool = True,\\n skip_no_class: bool = True,\\n):\\n maps = get_maps(maps_ath, MAPS_EXT)\\n gt_maps = get_maps(gt_maps_path, GT_MAPS_EXT)\\n logger.info(\\n \\\"Found %i aerial maps and %i ground truth maps.\\\", len(\\n maps), len(gt_maps)\\n )\\n with tqdm(total=len(maps), desc=\\\"Maps\\\") as pbar:\\n for m in maps:\\n try:\\n ortho_map = Image.open(m)\\n gt_map = Image.open(get_gt_map(m, gt_maps))\\n\\n if ortho_map.size == gt_map.size:\\n ortho_map_cv2 = pil_to_opencv(ortho_map)\\n gt_map_cv2 = pil_to_opencv(gt_map)\\n boxes = gen_crop_area(\\n SET_RESOLUTION[0], SET_RESOLUTION[1], ortho_map.size\\n )\\n center_points = gen_center_points(\\n SET_RESOLUTION[0], SET_RESOLUTION[1], ortho_map.size\\n )\\n with tqdm(\\n total=len(boxes),\\n leave=False,\\n desc=\\\"Sets for {}\\\".format(os.path.basename(m)),\\n ) as pbar2:\\n for b in boxes:\\n map_crop = ortho_map.crop(b)\\n gt_map_crop = gt_map.crop(b)\\n\\n if add_to_set(\\n map_crop,\\n gt_map_crop,\\n skip_black=skip_black,\\n skip_water=skip_water,\\n skip_no_class=skip_no_class,\\n ):\\n map_fn = os.path.join(\\n path[1], \\\"{}_x.png\\\".format(ds_index)\\n )\\n gt_map_fn = os.path.join(\\n path[2], \\\"{}_y.png\\\".format(ds_index)\\n )\\n map_crop.save(map_fn)\\n gray_gt_map_crop = reduce_and_grayscale(\\n gt_map_crop)\\n gray_gt_map_crop.save(gt_map_fn)\\n ds_index += 1\\n\\n pbar2.set_description(\\n \\\"Sets for {}(index: {})\\\".format(\\n os.path.basename(m), ds_index\\n )\\n )\\n pbar2.update()\\n else:\\n continue\\n except Exception as e:\\n logger.error(\\\"Error occurred while creating set: %s\\\", e)\\n logger.error(\\\"Skipping %s\\\", m)\\n pbar.update()\",\n \"def create_trials(self):\\n exp_s = self.settings['experiment']\\n\\n # get stimuli\\n with h5py.File(exp_s['stim_file'], 'r') as f:\\n self.stim_rgb_arr = np.array(f['patterns'])\\n self.stimuli = [GratingStim(win=self.session.win, tex=s.T)\\n for s in self.stim_rgb_arr]\\n self.fixation_dot = Circle(self.win, radius=0.1, edges=100, color='r')\\n\\n # timings that define how many trials etc.\\n mean_trial_duration = exp_s['isi_min'] + exp_s['isi_mean']\\n self.n_trials = round(\\n (exp_s['total_run_duration'] - (exp_s['start_end_period'] * 2)) / mean_trial_duration)\\n tolerance_range = [exp_s['total_run_duration'] - exp_s['temporal_tolerance'],\\n exp_s['total_run_duration'] + exp_s['temporal_tolerance']]\\n\\n # and then search for the right isis to fill up the experiment exactly.\\n isis = np.random.exponential(\\n exp_s['isi_mean'], n_trials) + exp_s['isi_min']\\n exp_duration = isis + (exp_s['start_end_period'] * 2)\\n while exp_duration < tolerance_range[0] or exp_duration > tolerance_range[1]:\\n isis = np.random.exponential(\\n exp_s['isi_mean'], n_trials) + exp_s['isi_min']\\n exp_duration = isis + (exp_s['start_end_period'] * 2)\\n pretimes = np.zeros(self.n_trials)\\n pretimes[[0, -1]] = exp_s['start_end_period']\\n\\n # deciding which stimuli to show when\\n self.how_many_images_per_trial = exp_s['stim_flicker_freq'] * \\\\\\n exp_s['stim_duration']\\n self.duration_per_image = 1.0/exp_s['stim_flicker_freq']\\n\\n trial_images = np.random.randint(len(self.stimuli), size=(\\n self.n_trials, self.how_many_images_per_trial))\\n\\n for i in range(self.n_trials):\\n self.trials.append(HRFMapperTrial(\\n session=self,\\n trial_nr=i,\\n phase_durations=[\\n pretimes[i], exp_s['stim_duration'], isis[i]-exp_s['stim_duration']],\\n phase_names=['slack', 'stim', 'isi'],\\n parameters={'isi': isis[i],\\n 'stim_list': trial_images[i]},\\n timing='seconds',\\n load_next_during_phase=None,\\n verbose=True,\\n condition='hrf'\\n ))\",\n \"def loadTrial(trialPath):\\r\\n\\r\\n trialDict = ft.loadFile(trialPath)\\r\\n\\r\\n trial = RetinotopicMappingTrial(mouseID=trialDict['mouseID'], # str, mouseID\\r\\n dateRecorded=trialDict['dateRecorded'], # int, date recorded, yearmonthday\\r\\n comments=trialDict['comments'], # str, number of the trail on that day\\r\\n altPosMap=trialDict['altPosMap'], # altitude position map\\r\\n aziPosMap=trialDict['aziPosMap'], # azimuth position map\\r\\n altPowerMap=trialDict['altPowerMap'], # altitude power map\\r\\n aziPowerMap=trialDict['aziPowerMap'], # azimuth power map\\r\\n vasculatureMap=trialDict['vasculatureMap'], # vasculature map\\r\\n params=trialDict['params'])\\r\\n\\r\\n try:\\r\\n trial.altPosMapf = trialDict['altPosMapf']\\r\\n except KeyError:\\r\\n pass\\r\\n\\r\\n try:\\r\\n trial.aziPosMapf = trialDict['aziPosMapf']\\r\\n except KeyError:\\r\\n pass\\r\\n\\r\\n try:\\r\\n trial.altPowerMapf = trialDict['altPowerMapf']\\r\\n except KeyError:\\r\\n pass\\r\\n\\r\\n try:\\r\\n trial.aziPowerMapf = trialDict['aziPowerMapf']\\r\\n except KeyError:\\r\\n pass\\r\\n\\r\\n try:\\r\\n if isinstance(trialDict['finalPatches'].values()[0], dict):\\r\\n trial.finalPatches = {}\\r\\n for area, patchDict in trialDict['finalPatches'].items():\\r\\n try:\\r\\n trial.finalPatches.update({area: Patch(patchDict['array'], patchDict['sign'])})\\r\\n except KeyError:\\r\\n trial.finalPatches.update({area: Patch(patchDict['sparseArray'], patchDict['sign'])})\\r\\n else:\\r\\n pass\\r\\n except KeyError:\\r\\n pass\\r\\n\\r\\n try:\\r\\n if isinstance(trialDict['finalPatchesMarked'].values()[0], dict):\\r\\n trial.finalPatchesMarked = {}\\r\\n for area, patchDict in trialDict['finalPatchesMarked'].items():\\r\\n try:\\r\\n trial.finalPatchesMarked.update({area: Patch(patchDict['array'], patchDict['sign'])})\\r\\n except KeyError:\\r\\n trial.finalPatchesMarked.update({area: Patch(patchDict['sparseArray'], patchDict['sign'])})\\r\\n else:\\r\\n pass\\r\\n except KeyError:\\r\\n pass\\r\\n\\r\\n try:\\r\\n trial.signMap = trialDict['signMap']\\r\\n except KeyError:\\r\\n pass\\r\\n\\r\\n try:\\r\\n trial.signMapf = trialDict['signMapf']\\r\\n except KeyError:\\r\\n pass\\r\\n\\r\\n try:\\r\\n trial.rawPatchMap = trialDict['rawPatchMap']\\r\\n except KeyError:\\r\\n pass\\r\\n\\r\\n try:\\r\\n trial.rawPatches = trialDict['rawPatches']\\r\\n except KeyError:\\r\\n pass\\r\\n\\r\\n try:\\r\\n trial.eccentricityMapf = trialDict['eccentricityMapf']\\r\\n except KeyError:\\r\\n pass\\r\\n\\r\\n return trial\",\n \"def generate_test_images():\\n results = {}\\n for antialias, aa_descriptor in antialias_options:\\n for canvas, canvas_descriptor in canvas_options:\\n for func in (generate_test_001,\\n generate_test_002,\\n generate_test_003,\\n generate_test_004,\\n generate_test_005,\\n generate_test_007,\\n ):\\n points, name = func()\\n aggregators = draw_lines(canvas, points, antialias)\\n img = shade(aggregators, cmap=cmap01)\\n description = \\\"{}_{}_{}\\\".format(\\n name, aa_descriptor, canvas_descriptor)\\n results[description] = img\\n\\n for func in (generate_test_006, ):\\n points, name = func()\\n aggregator = draw_multi_segment_line(canvas, points, antialias)\\n img = shade(aggregator, cmap=cmap01)\\n description = \\\"{}_{}_{}\\\".format(\\n name, aa_descriptor, canvas_descriptor)\\n results[description] = img\\n return results\",\n \"def recordTrial(stim_trial_indices, instr_key, condition_binary, trial_target_times, possible_letters, wheel_matrix_info, ec, trial_path, record_pupil = True):\\n\\n\\t# DRAW SELECTIONS ON SCREEN\\n\\twheel_loc = CircularLayout(3, radius = .6, angles = [- phi, (phi / 2), 0]) # must be three wheels\\n\\tletter_loc = [];\\n\\tfor i in len(wheel_matrix_info):\\n\\t\\ttemp = CircularLayout(wheel_matrix_info[i], radius = .15, relative_center = wheel_loc.positions[i])\\n\\t\\tletter_loc.append(temp.positions)\\n\\n\\t# letterloc1 = CircularLayout(wheel_matrix_info[0], relative_center = wheel_loc.positions[0])\\n\\t# letterloc1 = CircularLayout(wheel_matrix_info[1], relative_center = wheel_loc.positions[1])\\n\\t# letterloc1 = CircularLayout(wheel_matrix_info[2], relative_center = wheel_loc.positions[2])\\n\\n\\t# DASCogLoad drawing for reference\\n\\t# cur_cols = np.where(attn[block][tnum], 'Lime', 'LightGray').tolist()\\n\\t# txt_obj = []\\n\\t# for n, cat in enumerate(cur_cats):\\n\\t# \\tcat = '<center>' + cat + '</center>' # hack (pyglet bug)\\n\\t# \\ttxt_obj.append(ec.screen_text(cat, pos=[xpos[n], ypos[n]],\\n\\t# \\t\\t\\t\\t\\t\\t\\t\\t color=cur_cols[n], font_size=36))\\n\\t# end_wait = ec.current_time + pretrial_wait\\n\\t# ec.flip()\\n\\n\\t# Refer to voc_meg.py and pupillometry.py and PylinkAPI.pdf for referenc on recording pupillometry\\n\\n\\t# load WAVs for this block\\n\\tec.screen_text('loading...')\\n\\tstims = []\\n\\tstims.append(read_wav(path)[0]) # ignore fs\\n\\tec.flip()\\n\\n\\n\\t# get ready\\n\\tstim_dur = stim.shape[-1] / ec.stim_fs\\n\\tec.load_buffer(stim)\\n\\tec.wait_until(end_wait)\\n\\n\\t# play stim\\n\\tec.start_stimulus(flip=False)\\n\\tec.stop()\\n\\n\\t# clear screen\\n\\tec.flip()\\n\\n\\t# write out data\\n\\tec.write_data_line('target_time', target_time)\\n\\tec.trial_ok()\\n\\n\\treturn stim_trial_indices\",\n \"def create_mapping(project, img):\\n with BMI(_username, _password, project) as bmi:\\n ret = bmi.mount_image(img)\\n if ret[constants.STATUS_CODE_KEY] == 200:\\n click.echo('Success')\\n else:\\n click.echo(ret[constants.MESSAGE_KEY])\",\n \"def trial_setup(params):\\n runs = []\\n trials = []\\n for run in range(params['runs']):\\n runs = runs + [run]*params['trials_per_run']\\n for trial in range(params['trials_per_run']):\\n trials.append(trial)\\n return(runs,trials)\",\n \"def createTrialDict(trial, block):\\n trial_type = ''\\n\\n if trial.visual_file:\\n visual_file = trial.visual_file.url\\n vftype = trial.visual_file.filetype\\n if 'video' in vftype.lower():\\n trial_type = 'video'\\n else:\\n trial_type = 'image'\\n else:\\n visual_file = ''\\n\\n if trial.audio_file:\\n audio_file = trial.audio_file.url\\n else:\\n audio_file = ''\\n\\n if not trial.response_keys:\\n trial.response_keys = ''\\n\\n trial_dict = {\\n 'trial_id': trial.id,\\n 'background_colour': block.background_colour,\\n 'label': trial.label,\\n 'visual_onset': trial.visual_onset,\\n 'audio_onset': trial.audio_onset,\\n 'audio_file': audio_file,\\n 'visual_file': visual_file,\\n 'max_duration': trial.max_duration,\\n 'response_keys': trial.response_keys.lower().replace(' ', '').split(','),\\n 'require_user_input': trial.user_input, #'NO', 'YES'\\n 'trial_type': trial_type,\\n 'record_media': trial.record_media,\\n }\\n return trial_dict\",\n \"def test_imageset_annotationset_download(\\n client, two_challenge_sets, phase, kind\\n):\\n\\n imageset = two_challenge_sets.challenge_set_1.challenge.imageset_set.get(\\n phase=phase\\n )\\n image_file = ImageFileFactory()\\n imageset.images.add(image_file.image)\\n\\n annotationset = AnnotationSetFactory(base=imageset, kind=kind)\\n annotation_file = ImageFileFactory()\\n annotationset.images.add(annotation_file.image)\\n\\n tests = [\\n # (\\n # image response + annotation response not test ground truth,\\n # annotation response - testing gt,\\n # user\\n # )\\n (403, 403, None),\\n (403, 403, UserFactory()),\\n (403, 403, UserFactory(is_staff=True)),\\n (403, 403, two_challenge_sets.challenge_set_1.non_participant),\\n (302, 403, two_challenge_sets.challenge_set_1.participant),\\n (302, 403, two_challenge_sets.challenge_set_1.participant1),\\n (302, 302, two_challenge_sets.challenge_set_1.creator),\\n (302, 302, two_challenge_sets.challenge_set_1.admin),\\n (403, 403, two_challenge_sets.challenge_set_2.non_participant),\\n (403, 403, two_challenge_sets.challenge_set_2.participant),\\n (403, 403, two_challenge_sets.challenge_set_2.participant1),\\n (403, 403, two_challenge_sets.challenge_set_2.creator),\\n (403, 403, two_challenge_sets.challenge_set_2.admin),\\n (302, 302, two_challenge_sets.admin12),\\n (302, 403, two_challenge_sets.participant12),\\n (302, 302, two_challenge_sets.admin1participant2),\\n ]\\n\\n for test in tests:\\n\\n response = get_view_for_user(\\n url=image_file.file.url, client=client, user=test[2]\\n )\\n assert response.status_code == test[0]\\n\\n response = get_view_for_user(\\n url=annotation_file.file.url, client=client, user=test[2]\\n )\\n if phase == ImageSet.TESTING and kind == AnnotationSet.GROUNDTRUTH:\\n # testing ground truth\\n assert response.status_code == test[1]\\n else:\\n # training ground truth, training predictions and\\n # ground truth predictions\\n assert response.status_code == test[0]\",\n \"def make_dataset():\\n\\n\\tnumberOfTrials = dataset_params.num_of_samples\\n\\tnumberOfTrials_train = int(numberOfTrials*0.8)\\n\\tnumberOfTrials_test = int(numberOfTrials*0.2)\\n\\n\\tprint(\\\"==================================================\\\")\\n\\tprint(\\\"1. Generating Train images ......\\\")\\n\\tprint(\\\"\\\\nTrain image per variation\\\", numberOfTrials_train)\\n\\tmakeDataset(numberOfTrials_train, \\\"train\\\")\\n\\n\\tprint(\\\"==================================================\\\")\\n\\tprint(\\\"2. Generating Test images ......\\\")\\n\\tprint(\\\"\\\\nTest image per variation\\\", numberOfTrials_test)\\n\\tmakeDataset(numberOfTrials_test, \\\"test\\\")\\n\\n\\tprint(\\\"==================================================\\\")\\n\\tprint(\\\"Done!!!\\\")\",\n \"def generate_scanset_metadata( image_set_dictionary, html_base_path, session_id ):\\r\\n\\tcur_subj_info = {}\\r\\n\\r\\n\\t\\\"\\\"\\\"need to think through the data structure a bit more.... but can always adjust later \\\"\\\"\\\"\\r\\n\\tcur_subj_info['session_id'] = session_id\\r\\n\\t#cur_subj_info['img_id'] = counter\\r\\n\\tcur_subj_info['subject_id'] = session_id.split('/')[0]\\r\\n\\tglobal counter\\r\\n\\t\\r\\n\\tnii_image_dict = image_set_dictionary['nii_images']\\r\\n\\tpng_image_dict = image_set_dictionary['png_image_set']\\r\\n\\r\\n\\tscan_metadata = {}\\r\\n\\tfor scan in nii_image_dict:\\r\\n\\t\\tprint \\\"propcessing \\\", scan\\r\\n\\t\\tnii_img = nii_image_dict[scan]['base_image'][0]\\r\\n\\t\\tprint nii_img\\r\\n#\\t\\tif 'mask' not in scan:\\r\\n\\r\\n#\\t\\tif 'mask' not in scan:\\r\\n#\\t\\t\\tnii_img = nii_image_dict[scan]['base_image'][0]\\r\\n#\\t\\telse:\\r\\n#\\t\\t\\tcontinue\\r\\n#\\t\\tprint \\\"HI DAVE!\\\"\\r\\n\\r\\n\\r\\n\\t\\tif not nii_img:\\r\\n\\t\\t\\tprint \\\"did not find base image for\\\",nii_image_dict\\r\\n\\t\\t\\tcontinue\\r\\n\\t\\tpng_img = html_path_root+ png_image_dict[scan]\\r\\n\\t\\tprint nii_img,\\\"is being passed\\\"\\r\\n\\r\\n\\t\\t(dim_x, dim_y, dim_z, vox_size_x, vox_size_y, vox_size_z, image_orientation )= igcf.get_nii_image_info(nii_img)\\r\\n\\t\\timage_info = Image.open(png_img)\\r\\n\\t\\twidth, height = image_info.size\\r\\n\\t\\t#print width,height,dim_x,dim_y,dim_z,vox_size_x,vox_size_y,vox_size_z\\t\\r\\n\\t\\tscan_info = {}\\r\\n\\t\\tscan_info['slice_width'] = dim_x\\r\\n\\t\\tscan_info['slice_height'] = dim_y\\r\\n\\t\\tscan_info['num_slices'] = dim_z\\r\\n\\t\\tscan_info['main_image_width'] = width\\r\\n\\t\\tscan_info['main_image_height'] = height\\r\\n\\t\\tscan_info['nii_image'] = nii_img\\r\\n\\t\\tscan_info['base_url'] = png_img.replace(html_path_root,'')\\r\\n\\t\\tscan_metadata[scan] = scan_info\\r\\n\\r\\n\\t\\t### There can be one or MORE masks for a given base image... so I will return a list of\\r\\n\\t\\t#dictionaries..\\r\\n\\t\\tmask_list = nii_image_dict[scan]['masks']\\r\\n\\t\\tmask_id = 0\\r\\n\\r\\n\\t\\tmask_info_list = []\\r\\n\\t\\tfor mask in mask_list:\\r\\n\\t\\t\\tcur_mask_info = {}\\r\\n\\t\\t\\t### I'll call the mask by it's basename\\r\\n\\t\\t\\tprint mask,\\\"was passed...\\\"\\r\\n\\t\\t\\tmask_base = os.path.basename(mask)\\r\\n\\t\\t\\tnii_img = nii_image_dict[scan]['masks'][mask_id]\\r\\n\\t\\t\\tprint nii_image_dict,'mask_id is',mask_id\\r\\n\\t\\t\\tprint \\\"nii maeg found should be\\\",nii_img\\r\\n\\t\\t\\tif not nii_img:\\r\\n\\t\\t\\t\\tprint \\\"did not find a valid mask image for \\\",nii_image_dict\\r\\n\\t\\t\\t\\tcontinue\\r\\n\\r\\n\\r\\n\\t\\t\\tcur_mask_info['name'] = mask_base\\r\\n\\t\\t\\tcur_mask_info['id'] = mask_id\\r\\n\\t\\t\\tcur_mask_info['nii_file'] = nii_img\\r\\n\\t\\t\\t## NEED TO ADD IN THE MASK_URL\\r\\n#\\t\\t\\tcur_mask_info['mask_url'] = \\t\\t\\t\\r\\n\\t\\t\\tprint png_image_dict\\r\\n\\t\\t\\tpng_img = html_path_root+ png_image_dict[scan]\\r\\n\\t\\t\\tprint nii_img,\\\"is being passed\\\"\\r\\n\\t\\t\\tcur_mask_info['mask_url'] = png_img.replace(html_path_root,'')\\r\\n\\r\\n\\t\\t\\tmask_info_list.append( cur_mask_info )\\r\\n\\t\\r\\n\\t\\t\\r\\n\\t\\t\\tmask_id +=1\\r\\n#\\t\\tprint cur_mask_info\\r\\n\\t\\tcur_subj_info['masks'] = mask_info_list\\r\\n\\t\\tscan_metadata[scan]['masks'] = [ mask_info_list]\\r\\n#\\t\\tprint mask_info_list\\r\\n\\r\\n\\tcur_subj_info['image_data'] = scan_metadata\\r\\n\\tcounter += 1\\t\\r\\n\\treturn { 'session_name': session_id , 'session_metadata': cur_subj_info }\",\n \"def gen_trial_inst_phase(self):\\n pm_action_flags = np.arange(2,2+self.nmaps)\\n return pm_action_flags,pm_action_flags\",\n \"def main(unused_argv):\\n with tf.io.gfile.GFile(_INTPUT_TRIPLET_LIST_FILEPATH.value, 'r') as fid:\\n triplets_list = np.loadtxt(fid, dtype=str)\\n\\n triplet_dicts = []\\n for triplet in triplets_list:\\n triplet_dict = {\\n image_key: os.path.join(_INPUT_DIR.value, triplet, image_basename)\\n for image_key, image_basename in _INTERPOLATOR_IMAGES_MAP.items()\\n }\\n triplet_dicts.append(triplet_dict)\\n p = beam.Pipeline('DirectRunner')\\n (p | 'ReadInputTripletDicts' >> beam.Create(triplet_dicts) # pylint: disable=expression-not-assigned\\n | 'GenerateSingleExample' >> beam.ParDo(\\n util.ExampleGenerator(_INTERPOLATOR_IMAGES_MAP))\\n | 'WriteToTFRecord' >> beam.io.tfrecordio.WriteToTFRecord(\\n file_path_prefix=_OUTPUT_TFRECORD_FILEPATH.value,\\n num_shards=_NUM_SHARDS.value,\\n coder=beam.coders.BytesCoder()))\\n result = p.run()\\n result.wait_until_finish()\\n\\n logging.info('Succeeded in creating the output TFRecord file: \\\\'%s@%s\\\\'.',\\n _OUTPUT_TFRECORD_FILEPATH.value, str(_NUM_SHARDS.value))\",\n \"def trial_logicals(trials, meta):\\n uobjs = list(set(meta['obj']))\\n nobjs = len(uobjs)\\n uimgs = list(meta['id'])\\n nimgs = len(uimgs)\\n use_trial_samples = 'choice' in list(trials.dtype.names)\\n summary = [{'sam':[],'dist':[],'choice':[],'imgind':[]} for i in range(nobjs)]\\n for i,OI in enumerate(uobjs):\\n summary[i]['sam'] = (trials['sample_obj'] == OI)\\n summary[i]['dist'] = (trials['dist_obj'] == OI)\\n summary[i]['imgind'] = np.array([uimgs.index(m['id']) for m in meta if (m['obj'] == OI) ])\\n if use_trial_samples:\\n summary[i]['choice'] = np.array(trials['choice'] == OI)\\n\\n image_summary =[{'id':[]} for i in range(nimgs)]\\n for i,OI in enumerate(uimgs):\\n image_summary[i]['id'] = (trials['id'] == OI)\\n return use_trial_samples, summary, image_summary\",\n \"def generate_dataset(self):\\n\\t\\timg_set = []\\n\\t\\tqa_set = []\\n\\t\\tfor i in range(self.config.dataset_size):\\n\\t\\t\\timg, r = self.generate_image()\\n\\t\\t\\tq = self.generate_question()\\n\\t\\t\\ta = self.generate_answer(r, q)\\n\\t\\t\\timg_sample = {\\n\\t\\t\\t\\t'id': i,\\n\\t\\t\\t\\t'image': img.tolist()\\n\\t\\t\\t}\\n\\t\\t\\timg_set.append(img_sample)\\n\\t\\t\\tfor j in range(len(q)):\\n\\t\\t\\t\\tqa_sample = {\\n\\t\\t\\t\\t\\t'id': i,\\n\\t\\t\\t\\t\\t'question': q[j].tolist(),\\n\\t\\t\\t\\t\\t'answer': a[j].tolist()\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tqa_set.append(qa_sample)\\n\\t\\tprint('Finished creating smaples')\\n\\t\\tdataset = {\\n\\t\\t\\t'image':\\timg_set,\\n\\t\\t\\t'qa':\\tqa_set\\n\\t\\t}\\n\\t\\twith open(self.path, 'w') as f:\\n\\t\\t\\tjson.dump(dataset, f)\",\n \"def generate_tpu(self, prompts: List[str]):\\n from flax.training.common_utils import shard # pylint:disable=g-import-not-at-top,g-importing-member\\n import jax # pylint:disable=g-import-not-at-top\\n import time # pylint:disable=g-import-not-at-top\\n import numpy as np # pylint:disable=g-import-not-at-top\\n\\n rng = jax.random.PRNGKey(0)\\n rng = jax.random.split(rng, jax.device_count())\\n\\n assert prompts, \\\"prompt parameter cannot be empty\\\"\\n print(\\\"Prompts: \\\", prompts)\\n prompt_ids = self._pipeline.prepare_inputs(prompts)\\n prompt_ids = shard(prompt_ids)\\n print(\\\"Sharded prompt ids has shape:\\\", prompt_ids.shape)\\n if self._run_with_profiler:\\n jax.profiler.start_trace(self._profiler_dir)\\n\\n time_start = time.time()\\n images = self._p_generate(prompt_ids, self._p_params, rng)\\n images = images.block_until_ready()\\n elapsed = time.time() - time_start\\n if self._run_with_profiler:\\n jax.profiler.stop_trace()\\n\\n print(\\\"Inference time (in seconds): \\\", elapsed)\\n print(\\\"Shape of the predictions: \\\", images.shape)\\n images = images.reshape(\\n (images.shape[0] * images.shape[1],) + images.shape[-3:])\\n print(\\\"Shape of images afterwards: \\\", images.shape)\\n return self._pipeline.numpy_to_pil(np.array(images))\",\n \"def sampling():\\n # make directory for street images\\n streetImageOutputFolder = CONFIG[\\\"sampling\\\"][\\\"streetImageOutputFolder\\\"]\\n makeDirectory(streetImageOutputFolder)\\n\\n # Get preprocessed point data\\n intersectionPointFile = CONFIG[\\\"shapefile\\\"][\\\"intersectoinPointFile\\\"]\\n pointInfoFile = CONFIG[\\\"shapefile\\\"][\\\"pointInfoFilename\\\"]\\n\\n pointInfo = readPointFile(pointInfoFile)\\n intersectionPointInfo = readIntersectionPointInfo(intersectionPointFile)\\n\\n # Filter point data that has street images taken within the specified period.\\n maxYear = CONFIG[\\\"gmap\\\"][\\\"streetImageMaxYear\\\"]\\n minYear = CONFIG[\\\"gmap\\\"][\\\"streetImageMinYear\\\"]\\n filteredPoints = filterPointByYear(pointInfo, maxYear, minYear)\\n\\n IMG_NAME_COL_NUM = 5\\n LAT_LNG_COL_NUM = 2\\n\\n # Sample street images, the return is list of sample info\\n sampleNum = CONFIG[\\\"sampling\\\"][\\\"sampleNum\\\"]\\n initImageNumber = CONFIG[\\\"sampling\\\"][\\\"initImageNumber\\\"]\\n sampleData = sampleAndDownloadStreetImage(filteredPoints, sampleNum, initImageNumber, initImageNumber, streetImageOutputFolder, intersectionPointInfo)\\n imageNames = [streetImageOutputFolder + \\\"/\\\" + data[IMG_NAME_COL_NUM] for data in sampleData]\\n links = GDriveUpload(imageNames, \\\"Sampled_Image\\\")\\n\\n for i in xrange(len(sampleData)):\\n imageName = streetImageOutputFolder + \\\"/\\\" + sampleData[i][IMG_NAME_COL_NUM]\\n sampleData[i].append(links[imageName])\\n\\n columnTitle = [\\\"Sample Number\\\", \\\"Sampled Point Number\\\", \\\"Latitude + Longitude\\\", \\\"Heading\\\", \\\"Date\\\", \\\"Image Name\\\", \\\"Road Types\\\", \\\"Web Link\\\"]\\n sampleData.insert(0, columnTitle)\\n\\n # output to csv file\\n outputCSV(sampleData, CONFIG[\\\"sampling\\\"][\\\"csvFilename\\\"])\\n\\n # plot images map\\n sampledPoints = set([divideGPS(d[LAT_LNG_COL_NUM]) for d in sampleData[1:]])\\n plotSampledPointMap(list(sampledPoints), CONFIG[\\\"sampling\\\"][\\\"sampledPointsMapFilename\\\"])\",\n \"def img_map(ts):\\n image_map = \\\"\\\"\\n texdata = bpy.data.textures[ts.texture]\\n if ts.mapping == \\\"FLAT\\\":\\n image_map = \\\"map_type 0 \\\"\\n elif ts.mapping == \\\"SPHERE\\\":\\n image_map = \\\"map_type 1 \\\"\\n elif ts.mapping == \\\"TUBE\\\":\\n image_map = \\\"map_type 2 \\\"\\n\\n # map_type 3 and 4 in development (?) (ENV in pov 3.8)\\n # for POV-Ray, currently they just seem to default back to Flat (type 0)\\n # elif ts.mapping==\\\"?\\\":\\n # image_map = \\\" map_type 3 \\\"\\n # elif ts.mapping==\\\"?\\\":\\n # image_map = \\\" map_type 4 \\\"\\n if ts.use_interpolation: # Available if image sampling class reactivated?\\n image_map += \\\" interpolate 2 \\\"\\n if texdata.extension == \\\"CLIP\\\":\\n image_map += \\\" once \\\"\\n # image_map += \\\"}\\\"\\n # if ts.mapping=='CUBE':\\n # image_map+= \\\"warp { cubic } rotate <-90,0,180>\\\"\\n # no direct cube type mapping. Though this should work in POV 3.7\\n # it doesn't give that good results(best suited to environment maps?)\\n # if image_map == \\\"\\\":\\n # print(\\\" No texture image found \\\")\\n return image_map\",\n \"def gen_ep_data(self,ntrials,trlen):\\n ## instruction\\n # for each trial, generate random instruction encoding sequence\\n i_encoding_input = np.array([\\n np.random.permutation(np.arange(1,self.nmaps+1)) \\n for i in range(ntrials)\\n ])\\n i_test_input = np.zeros([ntrials,trlen])\\n i_input = np.concatenate([\\n i_encoding_input,i_test_input],\\n 1).astype(int).reshape(-1) # (ntrials,trlen+)\\n ## stimulus\\n x_encoding_input = i_encoding_input\\n x_test_input = np.random.randint(1,self.nmaps+1,[ntrials,trlen])\\n x_input = np.concatenate([i_encoding_input,x_test_input],1)\\n ''' \\n embed x_input: \\n [ntrials,nmaps+trlen] -> s_input [ntrials*(nmaps+trlen),edim]\\n explicit loop required for flatten and embedd x_input\\n because if switchmaps=1, matrix is resorted between trials\\n and therefore same stimulus token integers correspond to\\n different stimulus embeddings on different trials\\n '''\\n s_input = -np.ones([ntrials,(self.nmaps+trlen),self.stimdim])\\n for trialn,x_input_trial in enumerate(x_input): \\n if self.switchmaps: self.resort_emat()\\n s_input[trialn] = self.emat[x_input_trial]\\n \\n # format output\\n i_input = tr.unsqueeze(tr.LongTensor(i_input),1)\\n s_input = tr.unsqueeze(tr.Tensor(np.concatenate(s_input)),1)\\n yseq = tr.unsqueeze(tr.LongTensor(x_input.reshape(-1)),1)\\n if return_trial_flag:\\n tr_flag = np.concatenate([i*np.ones(self.nmaps+trlen) for i in range(ntrials)])\\n tr_flag = tr.unsqueeze(tr.LongTensor(tr_flag),1)\\n return tr_flag,i_input,s_input,yseq,\\n else:\\n return i_input,s_input,yseq\",\n \"def makeDataset(numberOfTrials, data_type):\\n\\n\\tdata_folder = data_type + \\\"_images\\\"\\n\\tlabel_file = os.path.join(dataset_params.data_path, data_type + \\\"_lables.csv\\\")\\n\\n\\tutils.create_directory(dataset_params.data_path)\\n\\tutils.create_directory(os.path.join(dataset_params.data_path, data_folder))\\n\\n\\tallowedRadius = utils.defineShapePerimeter()\\n\\tcolorsRGB = utils.defineColorValues()\\n\\tshapeDict = utils.defineShapeSides()\\n\\tpadding = dataset_params.padding\\n\\n\\tnum = 0\\n\\toutput_images = [[\\\"figNum\\\", \\\"shape\\\", \\\"color\\\", \\\"size\\\", \\\"background\\\", \\\"quadrant\\\", \\\"radius\\\"]]\\n\\tfor c in dataset_params.colors: # for all 7 foreground colors \\n\\t\\tfor q in dataset_params.quadrants: # for all 4 quadratns \\n\\t\\t\\tfor s in dataset_params.shapes: # for all 5 shapes\\n\\t\\t\\t\\tfor k in dataset_params.sizes: # for all 3 sizes\\n\\t\\t\\t\\t\\tfor b in dataset_params.backgrounds: # for all 3 background colors\\n\\t\\t\\t\\t\\t\\tfor i in range(numberOfTrials):\\n\\t\\t\\t\\t\\t\\t\\tfileName = os.path.join(dataset_params.data_path, data_folder, str(num) + \\\".png\\\")\\n\\t\\t\\t\\t\\t\\t\\tpresentQuadrant = dataset_params.quadrants[q]\\n\\t\\t\\t\\t\\t\\t\\tradius = random.randint(allowedRadius[s][k][0],allowedRadius[s][k][1])\\n\\n\\t\\t\\t\\t\\t\\t\\tif(presentQuadrant == 3):\\n\\t\\t\\t\\t\\t\\t\\t\\txMin = 128 + padding\\n\\t\\t\\t\\t\\t\\t\\t\\txMax = 255 - radius\\n\\t\\t\\t\\t\\t\\t\\t\\tyMin = 128 + padding\\n\\t\\t\\t\\t\\t\\t\\t\\tyMax = 255 - radius\\n\\n\\t\\t\\t\\t\\t\\t\\telif(presentQuadrant == 2):\\n\\t\\t\\t\\t\\t\\t\\t\\txMin = 0 + radius\\n\\t\\t\\t\\t\\t\\t\\t\\txMax = 128 - padding\\n\\t\\t\\t\\t\\t\\t\\t\\tyMin = 128 + padding\\n\\t\\t\\t\\t\\t\\t\\t\\tyMax = 255 - radius\\n\\n\\t\\t\\t\\t\\t\\t\\telif(presentQuadrant == 1):\\n\\t\\t\\t\\t\\t\\t\\t\\txMin = 0 + radius\\n\\t\\t\\t\\t\\t\\t\\t\\txMax = 128 - padding\\n\\t\\t\\t\\t\\t\\t\\t\\tyMin = 0 + radius\\n\\t\\t\\t\\t\\t\\t\\t\\tyMax = 128 - padding\\n\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\txMin = 128 + padding\\n\\t\\t\\t\\t\\t\\t\\t\\txMax = 255 - radius\\n\\t\\t\\t\\t\\t\\t\\t\\tyMin = 0 + radius\\n\\t\\t\\t\\t\\t\\t\\t\\tyMax = 128 - padding\\n\\n\\t\\t\\t\\t\\t\\t\\txCenter = random.randint(xMin, xMax)\\n\\t\\t\\t\\t\\t\\t\\tyCenter = random.randint(yMin, yMax)\\n\\t\\t\\t\\t\\t\\t\\tcenter = [xCenter, yCenter]\\n\\n\\t\\t\\t\\t\\t\\t\\tif(s == \\\"circle\\\"):\\n\\t\\t\\t\\t\\t\\t\\t\\toutput_images.append([num, \\\"circle\\\", c, k, b, presentQuadrant, radius])\\n\\t\\t\\t\\t\\t\\t\\t\\timg = makeCircle(c, radius, center, b, colorsRGB)\\n\\t\\t\\t\\t\\t\\t\\t\\timg = img[:,:,::-1]\\n\\t\\t\\t\\t\\t\\t\\t\\tcv2.imwrite(fileName, img)\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\tn = shapeDict[s]\\n\\t\\t\\t\\t\\t\\t\\t\\timg = makePolygon(center, n, radius, b, c, colorsRGB)\\n\\t\\t\\t\\t\\t\\t\\t\\timg = img[:,:,::-1]\\n\\t\\t\\t\\t\\t\\t\\t\\tcv2.imwrite(fileName, img)\\n\\t\\t\\t\\t\\t\\t\\t\\toutput_images.append([num, s, c, k, b, presentQuadrant, radius])\\n\\t\\t\\t\\t\\t\\t\\tnum += 1\\n\\t\\n\\tprint(\\\"Number of image generated\\\", num)\\n\\n\\tprint(\\\"Saving \\\" + data_type + \\\" data meta information to CSV ......\\\")\\n\\tdf = pd.DataFrame(output_images[1:], columns=output_images[0])\\n\\tdf.to_csv(label_file, index=False)\\n\\tprint(\\\"Saved \\\" + data_type + \\\" data meta information: \\\" + data_folder)\\n\\t\\n\\n\\tprint(\\\"Saving \\\" + data_type + \\\" images data to npz(numpy) compressed file ......\\\")\\n\\tmake_npz_file(data_type)\\n\\tprint(\\\"Saved \\\" + data_type + \\\" images data to npz(numpy) compressed file!\\\")\\n\\t\\n\\treturn None\",\n \"def kitti_training_set(DATASET_PATH, scenes=['city', 'residential', 'road'], is_rgb = False):\\n KITTI_scenes = scenes\\n\\n if is_rgb == True:\\n data_path = 'image_02/data'\\n else:\\n data_path = 'image_00/data'\\n\\n clips = []\\n for scene in KITTI_scenes:\\n scene_path = join(DATASET_PATH, scene)\\n for s in sorted(listdir(scene_path)):\\n if isdir(join(scene_path, s)):\\n scene_date_path = join(scene_path, s)\\n for d in sorted(listdir(scene_date_path)):\\n if isdir(join(scene_date_path, d)):\\n img_folder = join(join(scene_date_path, d), data_path)\\n all_frames = []\\n # loop over all the images in the folder (0.png,1.png,..,199.png)\\n for i in sorted(listdir(img_folder)):\\n if str(join(img_folder, i))[-3:] == \\\"png\\\":\\n img_path = join(img_folder, i)\\n all_frames.append(img_path)\\n # get the 10-frames sequences from the list of images after applying data augmentation\\n for stride in range(1, 2):\\n clips.extend(get_clips_by_stride(stride=stride, frames_list=all_frames, sequence_size=11))\\n return clips\",\n \"def extract_data(filename, images_dir, output_dir, trials_idx, block_nums, goal_dict):\\n num_images = len(trials_idx) * len(block_nums)\\n f = h5py.File(os.path.join(output_dir, filename), 'w')\\n X = f.create_dataset('X', (num_images, IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS*NUM_FRAMES), dtype=TYPE)\\n Y = f.create_dataset('Y', (num_images, 2), dtype=TYPE)\\n\\n image_count = 0\\n for trial_num in trials_idx:\\n for block_num in block_nums:\\n print('Blocks ' + str(block_num) + ' Trial ' + str(trial_num))\\n for frame_num in xrange(0, NUM_FRAMES):\\n temp = imread(images_dir+'RTr_Bl'+str(block_num)+'_'+str(trial_num)+'_'+str(frame_num)+IMAGE_FORMAT)\\n temp = imresize(temp, [temp.shape[0]//DOWN_SAMPLE, temp.shape[1]//DOWN_SAMPLE, temp.shape[2]])\\n X[image_count, 0:temp.shape[0], 0:temp.shape[1], frame_num*NUM_CHANNELS:(frame_num+1)*NUM_CHANNELS] = temp\\n label = goal_dict['RTr_Bl'+str(block_num)+'_'+str(trial_num)]\\n Y[image_count, :] = [label, 1-label]\\n image_count += 1\\n\\n f.close()\\n\\n # TODO Use pixel depth normalization???\\n #data = (data - (PIXEL_DEPTH / 2.0)) / PIXEL_DEPTH\",\n \"def generate_test():\\n o = []\\n pos = [384, 288]\\n note_group_size = GAN_PARAMS[\\\"note_group_size\\\"]\\n generate_set(begin=3 * note_group_size, start_pos=pos,\\n length_multiplier=dist_multiplier, group_id=3, plot_map=True)\",\n \"def __make_tms(self, abspath_dir_img):\\n zoom_list = [ZOOM_MIN, ZOOM_MAX]\\n tif = Utils.get_file(abspath_dir_img, is_tif=True)\\n GenerateTMS.main(\\n tif, BAND_R, BAND_G, BAND_B, abspath_dir_img, zoom_list,\\n URL_TMS, DIR_TMS\\n )\",\n \"def runtrials_withmap(name, configs, test, N=20, gui=False, rosbag=True):\\n print \\\"*** %s ***\\\" % name\\n scriptdir = \\\"%s/%s\\\" % (os.getcwd(), name)\\n if os.path.exists(scriptdir):\\n print \\\"WARNING: directory %s already exists, skipping script\\\" % scriptdir\\n return False\\n os.mkdir(scriptdir)\\n evman = init(scriptdir)\\n evman.initBaseSystem(gui)\\n evman.initRviz(gui)\\n evman.initMapping(scriptdir)\\n # --- INITIAL MAP ---\\n mapdir = \\\"%s/map\\\" % os.getcwd()\\n if os.path.exists(mapdir):\\n print \\\"Found map directory, skipping map creation\\\"\\n else:\\n os.mkdir(mapdir)\\n evman.initSearchMan(dl=0, log=scriptdir)\\n evman.runTest()\\n evman.stopSearchMan()\\n evman.call(\\\"rosservice call /next_best_view_node/write_map %s/\\\" % mapdir)\\n for n in range(N):\\n psd = \\\"%s/psd\\\" % scriptdir\\n os.mkdir(psd)\\n xypose = None\\n for cname, search_kwargs in configs:\\n print \\\"# Evaluating n=%i %s\\\" % (n, cname)\\n logdir = \\\"%s/%s_%i\\\" % (scriptdir, cname, n)\\n os.mkdir(logdir)\\n evman.resetGzworld()\\n xypose = evman.setCamera(xypose)\\n evman.call(\\\"rosservice call /next_best_view_node/load_map %s/\\\" % mapdir)\\n evman.initSearchMan(psd=psd, log=logdir, **search_kwargs)\\n if rosbag:\\n evman.recordRosbag(logdir)\\n evman.runTest(**test)\\n evman.stopRosbag()\\n evman.stopSearchMan()\\n # --- CLEANUP ---\\n try:\\n shutil.rmtree(psd)\\n except OSError:\\n print \\\"WARNING: Expected to see persistent_samples, but there were none!\\\"\\n evman.shutdown()\\n return True\",\n \"def generate_stimuli(num_trials=10, stim_dur=0.08, fs=24414., rms=0.01,\\n ramp_noise=0.03, ramp_tone=0.06,\\n output_dir=None, save_as='mat', rand_seed=0):\\n if rand_seed is None:\\n rng = np.random.RandomState()\\n else:\\n rng = np.random.RandomState(rand_seed)\\n\\n # check input arguments\\n if save_as not in ['dict', 'wav', 'mat']:\\n raise ValueError('\\\"save_as\\\" must be \\\"dict\\\", \\\"wav\\\", or \\\"mat\\\"')\\n\\n if fs is None:\\n fs = get_tdt_rates()['25k']\\n\\n # General params:\\n n = int(stim_dur * fs) # total number of samples\\n t = np.linspace(0, stim_dur, n, endpoint=False) # time index for ploting\\n\\n#### make tone complex#########################################################\\n\\n tonecomp = np.zeros(24414. * stim_dur, float)\\n fund = 250.0 # fundamental frequency\\n for x in xrange(1, 5):\\n freq = fund*x\\n tonecomp = tonecomp + np.sin(freq * 2 * np.pi * np.arange\\n (int(fs * stim_dur)) / float(fs))\\n # windowing and onset/offset\\n finalstim_tc = window_edges(tonecomp, fs, ramp_tone, -1, 'hamming')\\n\\n return finalstim_tc\\n\\n##### make noise burst#########################################################\\n\\n # add 50 points extra\\n nb = np.random.normal(0, 1.0, int(fs * stim_dur) + 50)\\n\\n ### highpass cut-off freq of 1500Hz using 100th order Hamming ###\\n b = sig.firwin(101, 1500. / (fs / 2), pass_zero=False) # False - highpass\\n # nyq_rate = fs / 2\\n # have to add '1' order\\n filtered_stim = sig.lfilter(b, 1.0, nb)\\n\\n ### cut off extra 50 points from noiseburst ###\\n filtered_stim = filtered_stim[50:]\\n # windowing and onset/offset\\n nb_ramped = window_edges(nb[50:], fs, ramp_noise, -1, 'hamming')\\n finalstim_nb = np.multiply(nb_ramped, filtered_stim)\\n\\n return finalstim_nb\",\n \"def train(scope=''):\\n # with tf.Graph().as_default(), tf.device('/cpu:0'):\\n # Create a variable to count the number of train() calls. This equals the\\n # number of batches processed * FLAGS.num_gpus.\\n\\n train_dirs = FLAGS.datasets.split(':')\\n\\n\\n _images, _shapes, _reference_shape, pca_model, shape_space, _inits= \\\\\\n data_provider.load_images(train_dirs)\\n idx_list = range(len(_images))\\n\\n def get_random_sample(num, rotation_stddev=10):\\n # idx = np.random.randint(low=0, high=len(_images))\\n images = []\\n shapes = []\\n inits =[]\\n shape_3D = []\\n inits_3D = []\\n for i in range(FLAGS.batch_size):\\n rand_num = np.random.randint(0, num)\\n pixel_list = []\\n shape_list = []\\n # print('get_random_set:', idx)\\n im = menpo.image.Image(_images[rand_num].transpose(2, 0, 1), copy=False)\\n lms = _shapes[rand_num]\\n\\n init = _inits[rand_num]\\n\\n im.landmarks['PTS'] = lms\\n\\n im.landmarks['inital'] = init\\n\\n\\n\\n if np.random.rand() < .5:\\n im = utils.mirror_image(im)\\n\\n if np.random.rand() < .5:\\n theta = np.random.normal(scale=rotation_stddev)\\n rot = menpo.transform.rotate_ccw_about_centre(lms, theta)\\n im = im.warp_to_shape(im.shape, rot)\\n\\n pixels = im.pixels.transpose(1, 2, 0).astype('float32')\\n\\n shape = im.landmarks['PTS'].lms.points.astype('float32')\\n\\n init_2 = im.landmarks['inital'].lms.points.astype('float32')\\n\\n pixel_list.append(pixels)\\n\\n pixel_list = np.array(pixel_list)\\n\\n inits.append(init_2)\\n images.append(pixel_list)\\n shapes.append(shape)\\n\\n\\n\\n return images, shapes, inits\\n\\n\\n\\n\\n print('Defining model...')\\n\\n # all placeholder for tf\\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n sess = tf.Session(config=config)\\n\\n\\n with tf.device('/gpu:0'):\\n\\n actor = DDPG.Actor(sess, shape_space, k_nearest, LR_A, REPLACEMENT)\\n\\n critic = DDPG.Critic(sess, LR_C, GAMMA, REPLACEMENT)\\n\\n\\n for var in tf.global_variables():\\n print(var.op.name, var)\\n print('------')\\n for var in tf.trainable_variables():\\n print(var.op.name, var)\\n\\n print('------')\\n for var in tf.moving_average_variables():\\n print(var.op.name, var)\\n print('------')\\n\\n # Build an initialization operation to run below.\\n init = tf.initialize_all_variables()\\n print('Initializing variables...')\\n sess.run(init)\\n print('Initialized variables.')\\n\\n\\n if FLAGS.pretrained_checkpoint_path:\\n variables_to_restore = tf.get_collection(\\n slim.variables.VARIABLES_TO_RESTORE)\\n ckpt = tf.train.get_checkpoint_state(FLAGS.pretrained_checkpoint_path)\\n var_name_list = ['convnet/conv_1/weights', 'convnet/conv_1/biases'\\n , 'convnet/conv_2/weights', 'convnet/conv_2/biases'\\n\\n , 'rnn/FC/weights', 'rnn/FC/biases'\\n , 'rnn/pred/weights', 'rnn/pred/biases'\\n]\\n for var in variables_to_restore:\\n if '/'.join(var.op.name.split('/')[2:]) in var_name_list:\\n restorer = tf.train.Saver({'/'.join(var.op.name.split('/')[2:]): var})\\n restorer.restore(sess, os.path.join(FLAGS.pretrained_checkpoint_path,\\n ckpt.model_checkpoint_path))\\n print(var.op.name)\\n print('%s: Pre-trained knn_2D model restored from %s' %\\n (datetime.now(), FLAGS.pretrained_checkpoint_path))\\n\\n\\n if OUTPUT_GRAPH:\\n tf.summary.FileWriter(\\\"logs/graph\\\", sess.graph)\\n summaries = tf.get_collection(tf.GraphKeys.SUMMARIES, '')\\n summary_writer = tf.summary.FileWriter(\\\"logs/\\\")\\n saver = tf.train.Saver()\\n\\n num = shape_space.shape[0]\\n loss_list = []\\n loss_a_list = []\\n idx_save = 0\\n for step in range(Max_step):\\n loss = 0\\n random.shuffle(idx_list)\\n image_train, shape_gt, inits = get_random_sample(len(idx_list))\\n\\n\\n for i in range(MAX_iteration):\\n b_a_hat = []\\n\\n b_a_ = []\\n\\n q = []\\n e = []\\n\\n states_2 = []\\n\\n for bs in range(FLAGS.batch_size):\\n\\n image = image_train[bs]\\n image = np.reshape(image,(1, 386 ,458,3)) # 383, 453 386,458\\n\\n '\\\"knn_2D initial\\\"'\\n\\n\\n state_2D = np.reshape(actor.choose_action_hat(inits[bs].reshape(1, PATCHES_2D, 2), image),(1, 136))\\n\\n\\n b_hat_k_nn = np.squeeze(\\n actor.choose_action_hat(inits[bs].reshape(1, PATCHES_2D, 2), image))\\n b_a_hat.append(b_hat_k_nn)\\n\\n k_nn_b_a_ = (\\n actor.choose_action(inits[bs].reshape(1, PATCHES_2D, 2), b_hat_k_nn,\\n image))\\n\\n if random.random() < 0.5:\\n b_a_.append(np.squeeze(\\n critic.choose_max(inits[bs].reshape(1, PATCHES_2D, 2), k_nn_b_a_,\\n image)))\\n else:\\n b_a_.append(b_hat_k_nn)\\n q_value = critic.q_value(inits[bs].reshape(1, PATCHES_2D, 2), b_hat_k_nn.reshape(1, PATCHES_2D, 2),\\n image)\\n error = rdn_model.normalized_rmse(\\n inits[bs].reshape(1, PATCHES_2D, 2) + b_hat_k_nn.reshape(1, PATCHES_2D, 2),\\n shape_gt[bs].reshape(1, PATCHES_2D, 2))\\n states_2.append(state_2D)\\n\\n q.append(q_value)\\n e.append(error)\\n\\n\\n b_a_ = np.array(b_a_)\\n\\n b_a_hat = np.array(b_a_hat)\\n\\n images = np.array(np.squeeze(image_train))\\n gts = np.array(np.squeeze(shape_gt))\\n inits = np.array(np.squeeze(inits))\\n\\n e = np.vstack(e).ravel().mean()\\n q = np.vstack(q).ravel().mean()\\n\\n\\n loss = critic.learn_supervised(inits, b_a_, images, gts)\\n\\n grad_supervised, loss_a = actor.learn_supervise(inits, np.reshape(gts,\\n [-1, PATCHES_2D, 2]).astype(\\n 'float32'), images)\\n\\n s_, r = rdn_model.step(sess, b_a_, inits, gts)\\n inits = s_\\n r = r.mean()\\n\\n print('Train_2D_Step:', step, 'Iterate_Steps:', i, 'R:', r, '2D_q_value:', q, '2D_error:', e, 'critic loss knn_2D:', loss, 'actor loss knn_2D :', loss_a)\\n if (idx_save % 100 == 0):\\n checkpoint_path = os.path.join(FLAGS.train_dir +'model.ckpt')\\n saver.save(sess, checkpoint_path, global_step=idx_save)\\n idx_save += 1\",\n \"def main(unused_argv):\\n # Collect the list of folder paths containing the input and golden frames.\\n triplets_list = tf.io.gfile.listdir(_INPUT_DIR.value)\\n\\n triplet_dicts = []\\n for triplet in triplets_list:\\n triplet_dicts.append({\\n image_key: os.path.join(_INPUT_DIR.value, triplet, image_basename)\\n for image_key, image_basename in _INTERPOLATOR_IMAGES_MAP.items()\\n })\\n\\n p = beam.Pipeline('DirectRunner')\\n (p | 'ReadInputTripletDicts' >> beam.Create(triplet_dicts) # pylint: disable=expression-not-assigned\\n | 'GenerateSingleExample' >> beam.ParDo(\\n util.ExampleGenerator(_INTERPOLATOR_IMAGES_MAP))\\n | 'WriteToTFRecord' >> beam.io.tfrecordio.WriteToTFRecord(\\n file_path_prefix=_OUTPUT_TFRECORD_FILEPATH.value,\\n num_shards=_NUM_SHARDS.value,\\n coder=beam.coders.BytesCoder()))\\n result = p.run()\\n result.wait_until_finish()\\n\\n logging.info('Succeeded in creating the output TFRecord file: \\\\'%s@%s\\\\'.',\\n _OUTPUT_TFRECORD_FILEPATH.value, str(_NUM_SHARDS.value))\",\n \"def main(num_trials, num_actions):\\n\\tfor i in xrange(int(num_trials)):\\n\\t\\ttrial(i+1, int(num_actions))\",\n \"def mapillary_sample():\\n return \\\"tests/data/mapillary/training/\\\"\",\n \"def generate_test_data(root: str) -> str:\\n size = (64, 64)\\n folder_path = os.path.join(root, \\\"enviroatlas_lotp\\\")\\n\\n if not os.path.exists(folder_path):\\n os.makedirs(folder_path)\\n\\n for prefix in tile_list:\\n for suffix, data_profile in layer_data_profiles.items():\\n img_path = os.path.join(folder_path, f\\\"{prefix}_{suffix}.tif\\\")\\n img_dir = os.path.dirname(img_path)\\n if not os.path.exists(img_dir):\\n os.makedirs(img_dir)\\n\\n data_profile[\\\"profile\\\"][\\\"height\\\"] = size[0]\\n data_profile[\\\"profile\\\"][\\\"width\\\"] = size[1]\\n data_profile[\\\"profile\\\"][\\\"transform\\\"] = Affine(\\n 1.0, 0.0, 608170.0, 0.0, -1.0, 3381430.0\\n )\\n\\n write_data(\\n img_path,\\n data_profile[\\\"profile\\\"],\\n data_profile[\\\"data_type\\\"],\\n data_profile[\\\"vals\\\"],\\n )\\n\\n # build the spatial index\\n schema = {\\n \\\"geometry\\\": \\\"Polygon\\\",\\n \\\"properties\\\": {\\n \\\"split\\\": \\\"str\\\",\\n \\\"naip\\\": \\\"str\\\",\\n \\\"nlcd\\\": \\\"str\\\",\\n \\\"roads\\\": \\\"str\\\",\\n \\\"water\\\": \\\"str\\\",\\n \\\"waterways\\\": \\\"str\\\",\\n \\\"waterbodies\\\": \\\"str\\\",\\n \\\"buildings\\\": \\\"str\\\",\\n \\\"lc\\\": \\\"str\\\",\\n \\\"prior_no_osm_no_buildings\\\": \\\"str\\\",\\n \\\"prior\\\": \\\"str\\\",\\n },\\n }\\n with fiona.open(\\n os.path.join(folder_path, \\\"spatial_index.geojson\\\"),\\n \\\"w\\\",\\n driver=\\\"GeoJSON\\\",\\n crs=\\\"EPSG:3857\\\",\\n schema=schema,\\n ) as dst:\\n for prefix in tile_list:\\n img_path = os.path.join(folder_path, f\\\"{prefix}_a_naip.tif\\\")\\n with rasterio.open(img_path) as f:\\n geom = shapely.geometry.mapping(shapely.geometry.box(*f.bounds))\\n geom = fiona.transform.transform_geom(\\n f.crs.to_string(), \\\"EPSG:3857\\\", geom\\n )\\n\\n row = {\\n \\\"geometry\\\": geom,\\n \\\"properties\\\": {\\n \\\"split\\\": prefix.split(\\\"/\\\")[0].replace(\\\"_tiles-debuffered\\\", \\\"\\\")\\n },\\n }\\n for suffix, data_profile in layer_data_profiles.items():\\n key = suffix_to_key_map[suffix]\\n row[\\\"properties\\\"][key] = f\\\"{prefix}_{suffix}.tif\\\"\\n dst.write(row)\\n\\n # Create archive\\n archive_path = os.path.join(root, \\\"enviroatlas_lotp\\\")\\n shutil.make_archive(archive_path, \\\"zip\\\", root_dir=root, base_dir=\\\"enviroatlas_lotp\\\")\\n shutil.rmtree(folder_path)\\n md5: str = calculate_md5(archive_path + \\\".zip\\\")\\n return md5\",\n \"def make_rand_task():\\n rand_type = all_tasks.keys()[random.randint(0, len(all_tasks.keys()) - 1)]\\n rand_hit = all_tasks[rand_type][random.randint(0, len(all_tasks[rand_type]) - 1)]\\n\\n if rand_hit['type'] == 'img':\\n rand_hit['img_src'] = get_rand_img()\\n\\n return rand_hit\",\n \"def generate_triplets(images, filenames, triplet_names):\\n _, h, w, c = images.shape\\n list_A = []\\n list_P = []\\n list_N = []\\n\\n triple = [[i[0]+'.jpg', i[1]+'.jpg',\\n i[2]+'.jpg'] for i in triplet_names]\\n\\n for elem in triple:\\n flagA, flagP, flagN = (0, 0, 0)\\n\\n A_name, P_name, N_name = elem\\n\\n if A_name in filenames:\\n flagA = 1\\n if P_name in filenames:\\n flagP = 1\\n if N_name in filenames:\\n flagN = 1\\n\\n if flagA and flagP and flagN:\\n index_A = filenames.index(A_name)\\n index_P = filenames.index(P_name)\\n index_N = filenames.index(N_name)\\n\\n A = images[index_A]\\n P = images[index_P]\\n N = images[index_N]\\n\\n list_A.append(A)\\n list_P.append(P)\\n list_N.append(N)\\n\\n list_A = [elem.reshape(1, h, w, c) for elem in list_A]\\n list_A = np.concatenate(list_A)\\n\\n list_P = [elem.reshape(1, h, w, c) for elem in list_P]\\n list_P = np.concatenate(list_P)\\n\\n list_N = [elem.reshape(1, h, w, c) for elem in list_N]\\n list_N = np.concatenate(list_N)\\n\\n return [list_A, list_P, list_N]\",\n \"def gen_test_output(sess, logits, image_folder, image_pl, data_folder,\\n learning_phase, image_shape, nw_shape):\\n image_paths = glob(os.path.join(data_folder, image_folder, '*.png'))\\n for image_file in image_paths[:5]:\\n\\n in_image = scipy.misc.imread(image_file, mode='RGB')\\n image = scipy.misc.imresize(in_image, image_shape)\\n\\n street_im = get_seg_img(sess, logits, image_pl, image, image_shape,\\n nw_shape, learning_phase)\\n\\n street_im = scipy.misc.imresize(street_im, in_image.shape)\\n yield os.path.basename(image_file), np.array(street_im)\",\n \"def samples_in_trial(self, trial_folder):\\n files = listdir(join(trial_folder, 'Background'))\\n img_files = [x for x in files if x.split(\\n '.')[-1] in ('tif', 'jpg', 'png')]\\n sample_name_list = [x.split('.')[1] for x in img_files]\\n return sample_name_list # like ['12B',]\",\n \"def genInput(tasksInfo, results, origLocation, destLocation, typeGray, samplSize = 0.10):\\n print '\\\\nbegin of genInput\\\\n'\\n # Training / aplication\\n treina = True\\n verdade = False\\n\\n # Sampling pixels from image\\n sampl = True\\n if sampl == True:\\n buildSampl = True\\n else:\\n buildSampl = False\\n\\n # Write data to file\\n if treina:\\n outInput = open('trainInput.dat', 'w')\\n #~ outInput1par = open('trainInput1par.dat', 'w')\\n outOutput = open('trainOutput.dat', 'w')\\n outTasks = open('trainTasks.dat', 'w')\\n #~ outOutputClass = open('trainOutputClass.dat', 'w')\\n selecOut = open('selected.dat', 'w')\\n else:\\n outInput = open('aplicInput.dat', 'w')\\n outTasks = open('aplicTasks.dat', 'w')\\n #~ outInput1par = open('aplicInput1par.dat', 'w')\\n if verdade:\\n outOutput = open('verdadeOutput.dat', 'w')\\n #~ outOutputClass = open('verdadeOutputClass.dat', 'w')\\n\\n #Setting info on temporary directory for images\\n numberImages = 12\\n tmpImg = []\\n for i in range(numberImages):\\n tmpImg.append(destLocation+\\\"tmpImg_n\\\"+str(i+1).zfill(2)+\\\"/\\\")\\n\\n imgFile = []\\n imgFile.append('2011352')\\n imgFile.append('2011353')\\n imgFile.append('2011355')\\n imgFile.append('2011357')\\n imgFile.append('2011358')\\n imgFile.append('2011359')\\n imgFile.append('2011360')\\n imgFile.append('2011361')\\n imgFile.append('2011362')\\n imgFile.append('2011363')\\n imgFile.append('2011364')\\n imgFile.append('2011365')\\n\\n #If we need to skip line\\n finishLine = True\\n #Getting number of tasks\\n numberTasks = len(tasksInfo)\\n print 'number of tasks: ', numberTasks\\n for task in range(numberTasks):\\n #Geting the selected day for each task\\n taskId = tasksInfo[task]['taskId']\\n for img in range(numberImages):\\n imgName = tmpImg[img] + str(taskId) + '.tif'\\n #Openning image (and testing)\\n if os.path.exists(imgName) is False:\\n print 'INPUT -> Task miss: ' + str(taskId) + ' Image: ' + str(img) + ' Name: ' + imgName\\n finishLine = False\\n continue\\n print 'INPUT -> Task: ' + str(taskId) + ' Image: ' + str(img)\\n fileSat = gdal.Open(imgName, GA_ReadOnly)\\n if fileSat is None:\\n print 'Could not open ' + imgName\\n sys.exit(1)\\n # Read band values from image\\n rows = fileSat.RasterYSize\\n cols = fileSat.RasterXSize\\n R_band_sat = fileSat.GetRasterBand(1)\\n G_band_sat = fileSat.GetRasterBand(2)\\n B_band_sat = fileSat.GetRasterBand(3)\\n R_data_sat = R_band_sat.ReadAsArray(0, 0, cols, rows)\\n G_data_sat = G_band_sat.ReadAsArray(0, 0, cols, rows)\\n B_data_sat = B_band_sat.ReadAsArray(0, 0, cols, rows)\\n #Closing image\\n fileSat = None\\n\\n #If we are sampling the image, then we'll pick our samples\\n print 'sampl: ', sampl\\n print 'buildSampl: ', buildSampl\\n if ((sampl == True) and (buildSampl == True)):\\n universe = []\\n samplList = []\\n random.seed(8225)\\n for i in range(rows):\\n for j in range(cols):\\n universe.append([i,j])\\n sizeUniverse = len(universe)\\n samplSizeInt = int(samplSize * sizeUniverse)\\n print 'Sampling mode activated.'\\n print 'Using ', samplSizeInt, ' out of ', sizeUniverse, ' pixels.'\\n for i in range(samplSizeInt):\\n samplList.append(universe.pop(random.randint(0,len(universe)-1)))\\n buildSampl = False\\n\\n sumValueGray = 0.0\\n if (sampl == False):\\n #Working with the values\\n for i in range(rows):\\n for j in range(cols):\\n #~ valueString = str(float(R_data_sat[i,j])/255.0)+' '+str(float(G_data_sat[i,j])/255.0)+' '+str(float(B_data_sat[i,j])/255.0)\\n valueGray = rgb2gray((float(R_data_sat[i,j])/255.0),(float(G_data_sat[i,j])/255.0),(float(B_data_sat[i,j])/255.0),typeGray)\\n sumValueGray = sumValueGray + valueGray\\n valueString = str(taskId)+' '+str(valueGray)\\n #~ outInput.write(\\\"%s \\\"%valueString)\\n sumValueString = str(taskId)+' '+str(sumValueGray/(rows*cols))\\n #~ outInput1par.write(\\\"%s \\\"%sumValueString)\\n outInput.write(\\\"%s \\\"%sumValueString)\\n else:\\n #Working with the sampled values\\n for idx in range(samplSizeInt):\\n i = samplList[idx][0]\\n j = samplList[idx][1]\\n valueGray = rgb2gray((float(R_data_sat[i,j])/255.0),(float(G_data_sat[i,j])/255.0),(float(B_data_sat[i,j])/255.0),typeGray)\\n sumValueGray = sumValueGray + valueGray\\n valueString = str(valueGray)\\n #~ outInput.write(\\\"%s \\\"%valueString)\\n sumValueString = str(sumValueGray/samplSizeInt)\\n #~ outInput1par.write(\\\"%s \\\"%sumValueString)\\n outInput.write(\\\"%s \\\"%sumValueString)\\n\\n #If we did not had a problem with missing task\\n if finishLine == True:\\n #Closing the line of the file\\n outInput.write(\\\"\\\\n\\\")\\n #~ outInput1par.write(\\\"\\\\n\\\")\\n outTasks.write(str(taskId)+\\\"\\\\n\\\")\\n else:\\n finishLine = True\\n\\n #If we are training (or we know the truth), then we also generate the truth\\n if treina or verdade:\\n selecName = '/home/eduardo/ForestWatchers/ann2besttile/results/tmpMosaic_n0/' + str(taskId) + '.tif'\\n #Openning image (and testing)\\n if os.path.exists(selecName) is False:\\n print 'OUTPUT -> Task miss: ' + str(taskId)\\n continue\\n #~ fileSelec = gdal.Open(selecName, GA_ReadOnly)\\n #~ if fileSelec is None:\\n #~ print 'Could not open ' + selecName\\n #~ sys.exit(1)\\n #~ # Read band values from image\\n #~ rows = fileSelec.RasterYSize\\n #~ cols = fileSelec.RasterXSize\\n #~ R_band_selec = fileSelec.GetRasterBand(1)\\n #~ G_band_selec = fileSelec.GetRasterBand(2)\\n #~ B_band_selec = fileSelec.GetRasterBand(3)\\n #~ R_data_selec = R_band_selec.ReadAsArray(0, 0, cols, rows)\\n #~ G_data_selec = G_band_selec.ReadAsArray(0, 0, cols, rows)\\n #~ B_data_selec = B_band_selec.ReadAsArray(0, 0, cols, rows)\\n #~ #Closing image\\n #~ fileSelec = None\\n#~ \\n #~ if (sampl == False):\\n #~ #Working with the values\\n #~ for i in range(rows):\\n #~ for j in range(cols):\\n #~ valueGray = rgb2gray((float(R_data_selec[i,j])/255.0),(float(G_data_selec[i,j])/255.0),(float(B_data_selec[i,j])/255.0),'gleam')\\n #~ valueString = str(valueGray)\\n #~ outOutput.write(\\\"%s \\\"%valueString)\\n #~ else:\\n #~ #Working with the values\\n #~ for idx in range(samplSizeInt):\\n #~ i = samplList[idx][0]\\n #~ j = samplList[idx][1]\\n #~ valueGray = rgb2gray((float(R_data_selec[i,j])/255.0),(float(G_data_selec[i,j])/255.0),(float(B_data_selec[i,j])/255.0),'gleam')\\n #~ valueString = str(valueGray)\\n #~ outOutput.write(\\\"%s \\\"%valueString)\\n#~ \\n #~ #Closing line of the file\\n #~ outOutput.write(\\\"\\\\n\\\")\\n\\n selectedTile = results[task].index(max(results[task]))\\n if selectedTile == 0:\\n selectedName = str(taskId) + ' 2011352'\\n selectedFile = '1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0'\\n elif selectedTile == 1:\\n selectedName = str(taskId) + ' 2011353'\\n selectedFile = '0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0'\\n elif selectedTile == 2:\\n selectedName = str(taskId) + ' 2011355'\\n selectedFile = '0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0'\\n elif selectedTile == 3:\\n selectedName = str(taskId) + ' 2011357'\\n selectedFile = '0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0'\\n elif selectedTile == 4:\\n selectedName = str(taskId) + ' 2011358'\\n selectedFile = '0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0'\\n elif selectedTile == 5:\\n selectedName = str(taskId) + ' 2011359'\\n selectedFile = '0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0'\\n elif selectedTile == 6:\\n selectedName = str(taskId) + ' 2011360'\\n selectedFile = '0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0'\\n elif selectedTile == 7:\\n selectedName = str(taskId) + ' 2011361'\\n selectedFile = '0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0'\\n elif selectedTile == 8:\\n selectedName = str(taskId) + ' 2011362'\\n selectedFile = '0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0'\\n elif selectedTile == 9:\\n selectedName = str(taskId) + ' 2011363'\\n selectedFile = '0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0'\\n elif selectedTile == 10:\\n selectedName = str(taskId) + ' 2011364'\\n selectedFile = '0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0'\\n elif selectedTile == 11:\\n selectedName = str(taskId) + ' 2011365'\\n selectedFile = '0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0'\\n #~ outOutputClass.write(\\\"%s\\\\n\\\"%selectedFile)\\n outOutput.write(\\\"%s\\\\n\\\"%selectedFile)\\n selecOut.write(\\\"%s\\\\n\\\"%selectedName)\\n\\n # Close files\\n outInput.close()\\n outTasks.close()\\n #~ outInput1par.close()\\n if treina or verdade:\\n outOutput.close()\\n #~ outOutputClass.close()\\n selecOut.close()\\n\\n statusGenInput = 0\\n print '\\\\nend of genInput\\\\n'\\n return statusGenInput\",\n \"def sample_images(opt, batches_done, monet_dataloader, photo_dataloader):\\n G_AB.eval()\\n G_BA.eval()\\n real_A = next(iter(monet_dataloader))[0].cuda()\\n fake_B = G_AB(real_A)\\n real_B = next(iter(photo_dataloader))[0].cuda()\\n fake_A = G_BA(real_B)\\n # Arange images along x-axis\\n real_A = make_grid(real_A, nrow=opt.batch_size, normalize=True)\\n real_B = make_grid(real_B, nrow=opt.batch_size, normalize=True)\\n fake_A = make_grid(fake_A, nrow=opt.batch_size, normalize=True)\\n fake_B = make_grid(fake_B, nrow=opt.batch_size, normalize=True)\\n # Arange images along y-axis\\n image_grid = torch.cat((real_A, fake_B, real_B, fake_A), 1)\\n save_image(image_grid, \\\"%s/%s/images/%s.png\\\" % (opt.checkpoints_dir, opt.name, batches_done), normalize=False)\",\n \"def run_script(sc):\\n \\n \\n \\n \\n \\n \\n #the size of the image\\n imageN = opts.imageN\\n #the size of the dictionary\\n dictsize = opts.dictsize\\n #the number of bands in high resolution\\n bands_h_N = opts.bands_h\\n \\n #the number of bands in low resolution\\n bands_l_N = opts.bands_l\\n \\n \\n #parameters for training. \\n c1 = opts.c1 # Default value: 0.4\\n \\n c2 = opts.c2 # Default value: 0.4\\n \\n c3 = opts.c3 # Default value: 0.8\\n \\n maxbeta = opts.maxbeta #Default value: 1e+6\\n \\n delta = opts.delta #Default value: 1e-4\\n beta = opts.beta #Default value: 0.01\\n \\n #The learning rate thresholding value\\n lamda = opts.lamda\\n \\n #number of iterations for training\\n train_iter =opts.n_iter\\n \\n #the number of partitions for the data parallelization into RDD blocks\\n partitions_N = opts.partitions\\n \\n \\n \\n #input data are in the from (# of samples) x (# of Bands)\\n #high resolution samples\\n data_h = sc.parallelize(genfromtxt(opts.inputhigh, delimiter=','), partitions_N).cache()\\n \\n #low resolution samples\\n data_l = sc.parallelize(genfromtxt(opts.inputlow, delimiter=','), partitions_N).cache()\\n\\n \\n #initializing the dictionary @ high resolution\\n dict_h_t = data_h.take(dictsize)\\n \\n #initializing the dictionary @ low resolution\\n dict_l_t = data_l.take(dictsize)\\n \\n \\n dict_h = np.transpose(dict_h_t)\\n dict_l = np.transpose(dict_l_t)\\n \\n print('>>>>>>>>>>>>>>>>')\\n print(data_h.count())\\n print(data_l.count())\\n \\n #bundling the input samples together\\n datain = data_h.zip(data_l).cache()\\n print('>>>>>>>>>>>>>>>>')\\n \\n print(dict_h.shape)\\n print(dict_l.shape)\\n \\n #optional: uncomment to save the initial values of the dictionaries\\n #mat2save = './tttmpinit' + '_' + str(imageN) + 'x' + str(dictsize) + '.mat' \\n #sio.savemat(mat2save, {'dicth_init':dict_h, 'dictl_init': dict_l})\\n \\n \\n #operational parameters to be broadcasted to the cluster\\n lamda_bc = sc.broadcast(lamda)\\n dictsize_bc = sc.broadcast(dictsize)\\n \\n \\n #broadcast the dictionaries....\\n dict_h_bc = sc.broadcast(dict_h)\\n dict_l_bc = sc.broadcast(dict_l)\\n \\n \\n #define and initialize the CDL object for optimization.\\n tmp = datain.map(lambda x: startCDL(x, dictsize_bc.value)).cache() \\n \\n \\n \\n wind = opts.window; \\n \\n #######################################\\n ##initialize the variables for error convergence checking...\\n err_h = 0;\\n err_l = 0;\\n \\n buff_size = 10 #to do - put this in arg in...\\n err_thrs = 0.01 #likewise\\n \\n m = 0\\n mm = 0\\n time_all = []\\t\\n ##keep the error buffer size as an even number.\\n if buff_size % 2 == 1:\\n buff_size += 1\\n \\n \\n err_h_all = []\\n \\n err_l_all = []\\n \\n dictall_high = []\\n dictall_low = []\\n #####################################3\\n \\n #entering optimization....\\n for k in range(train_iter):\\n \\n ########################################################\\n #cluster calculation start! \\n ttime3 = time.time()\\n \\n\\n ttime2 = time.time()\\n \\n ###dictionaries calculations and broadcasting to the cluster.\\n dict_ht_bc = sc.broadcast(np.squeeze(np.transpose(dict_h)))\\n dict_lt_bc = sc.broadcast(np.squeeze(np.transpose(dict_l)))\\n \\t\\n \\n dtdh = np.dot(np.squeeze(np.transpose(dict_h)), np.squeeze(dict_h)) + (c1 + c3)*np.eye(np.squeeze(np.transpose(dict_h).shape[0]))\\n dtdhinv_bc = sc.broadcast(inv(dtdh))\\n \\n dtdl = np.dot(np.squeeze(np.transpose(dict_l)), np.squeeze(dict_l)) + (c2 + c3)*np.eye(np.squeeze(np.transpose(dict_l).shape[0]))\\n dtdlinv_bc = sc.broadcast(inv(dtdl))\\n \\n time_upd = time.time()\\n \\n #update the CDL object \\n tmp = tmp.map(lambda x: updateCD(x,dict_ht_bc.value, dict_lt_bc.value, dtdhinv_bc.value, dtdlinv_bc.value,c1,c2,c3,k)).cache()\\n \\n \\n print('time elapsed for updating...')\\n print(time.time() - time_upd)\\n \\n \\n time_calc = time.time()\\n \\n \\n #extract the SxW and phi matrices for low and high resolution.\\n updvals = tmp.map(lambda x: getVals(x)).reduce(lambda x,y: calcSum3(x, y))\\n \\n print('time elapsed for calculating...')\\n print(time.time() - time_calc)\\n \\n print('****************************************')\\n \\n \\n print('time elapsed:')\\n print time.time()- ttime2\\n #cluster calculation done!\\n ##########################################################\\n \\n sw_h =np.array(updvals[0][0])\\n sw_l =np.array(updvals[0][1]) \\n print(sw_h.shape)\\n phi_h = np.array(updvals[1][0])\\n phi_l = np.array(updvals[1][1])\\n print(phi_h.shape)\\n \\n phi_h = np.reshape(phi_h, ((1, len(phi_h)))) + delta\\n \\n #calculate and normalize the new dictionaries\\n #a. high resolution\\n dict_h_upd = dict_h + sw_h/(phi_h)\\n dict_h = normD(dict_h_upd)\\n #b. low resolution\\n phi_l = np.reshape(phi_l, ((1, len(phi_l)))) + delta\\n \\n dict_l_upd = dict_l + sw_l/(phi_l)\\n \\n\\n \\n dict_l = normD(dict_l_upd)\\n print('dict_l upd')\\n print(np.array(dict_l))\\n #clean up your garbage!\\n sc._jvm.System.gc()\\n\\n #######################################################\\n \\n #error calculation over the cluster\\n if (k + 1) % wind == 0:\\n \\n err_all = tmp.map(lambda x: calcErr(dict_h, dict_l,x)).reduce(lambda x,y: calcSum2(x,y))\\n print('err_l')\\n print(np.array(err_all[1]))\\n err_h = math.sqrt(np.sum(np.array(err_all[0])) / (bands_h_N * imageN))\\n err_l = math.sqrt(np.sum(np.array(err_all[1])) / (bands_l_N * imageN))\\n \\n \\n print('ERROR HIGH:')\\n print(err_h)\\n \\n print('ERROR LOW:')\\n print(err_l)\\n sc._jvm.System.gc()\\n \\n ##############################\\n \\n #append errors & dictionaries (for checking for convergence over a sliding window)\\n err_h_all.append(err_h)\\n err_l_all.append(err_l)\\n \\n dictall_high.append(dict_h)\\n \\n dictall_low.append(dict_l)\\n \\n \\n ##check error convergence >>>start!\\n if m >= buff_size - 1:\\n print('checking for error convergence...')\\n tmp_h = err_h_all[m-buff_size + 1:m+1]\\n tmp_l = err_l_all[m-buff_size + 1:m+1]\\n \\n err_con_h = np.mean(tmp_h[:buff_size/2], axis=0) - np.mean(tmp_h[buff_size/2:], axis=0)\\n err_con_l = np.mean(tmp_l[:buff_size/2], axis=0) - np.mean(tmp_l[buff_size/2:], axis=0)\\n \\n if (abs(err_con_h) > err_thrs or abs(err_con_l) > err_thrs) and k >= train_iter/2 + 1 :\\n \\n minindex_l = np.array(tmp_h).argmin()\\n \\n minindex_h = np.array(tmp_l).argmin()\\n \\n \\n dict_h = np.array(dictall_high[minindex_h])\\n \\n dict_l = np.array(dictall_low[minindex_l])\\n print('break!')\\n \\n break\\n \\n \\n if mm >= buff_size:\\n dictall_high = []\\n dictall_low = []\\n mm = 0\\n print('...done!') \\n \\n m = m + 1\\n mm = mm + 1\\n ########################################\\n \\n #when done with this iteration remove the dictionaries from the cluster (to improve memory efficiency)\\n \\n dict_ht_bc.unpersist(blocking=True)\\n \\n \\n dict_lt_bc.unpersist(blocking=True)\\n \\n\\n \\n dtdhinv_bc.unpersist(blocking=True)\\n \\n dtdlinv_bc.unpersist(blocking=True)\\n \\n ########################################\\n \\n print('Time elapsed for this iteration: ')\\n ttime3 = time.time()-ttime3\\n print(ttime3)\\n time_all.append(ttime3)\\n #print('>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')\\n \\n ##optional: save the results of each iteration in a mat file.\\n #mat2save = './results' + str(imageN) + 'x' + str(k)+ '_' + str(dictsize) + '_' +str(partitions_N) + '.mat' \\n \\n #sio.savemat(mat2save, {'timeelapsed': ttime3, 'dicth':dict_h, 'dictl': dict_l, 'phi_h': phi_h, 'phi_l': phi_l, 'sw_h': sw_h, 'sw_l': sw_l, 'err_l':err_l, 'err_h': err_h})#, 'wh': wh, 'wl': wl})#'phih': phi_h, 'sw': sw})\\n \\n \\n #save error values and final dictionaries in a mat file.\\n \\n mat2savefin = './results_fin' + str(imageN) + 'x' + str(dictsize) + '_' +str(partitions_N) + '.mat' \\n \\n sio.savemat(mat2savefin, {'dicth':dict_h, 'dictl': dict_l, 'err_l': err_l_all, 'err_h': err_h_all, 'time_all': time_all})\\n \\n return 1\",\n \"def gen_test_output(sess, logits, keep_prob, image_pl, data_folder, image_shape):\\n for image_file in glob(os.path.join(data_folder, 'image_2', '*.png')):\\n image = scipy.misc.imresize(scipy.misc.imread(image_file), image_shape)\\n\\n im_softmax = sess.run(\\n [tf.nn.softmax(logits)],\\n {keep_prob: 1.0, image_pl: [image]})\\n im_softmax_road = im_softmax[0][:, 1].reshape(image_shape[0], image_shape[1])\\n segmentation_road = (im_softmax_road > 0.5).reshape(image_shape[0], image_shape[1], 1)\\n \\n im_softmax_other_road = im_softmax[0][:, 2].reshape(image_shape[0], image_shape[1])\\n segmentation_other_road = (im_softmax_other_road > 0.5).reshape(image_shape[0], image_shape[1], 1)\\n \\n # green road\\n mask_road = np.dot(segmentation_road, np.array([[0, 255, 0, 127]]))\\n mask_road = scipy.misc.toimage(mask_road, mode=\\\"RGBA\\\")\\n \\n # blue other_road\\n mask_other_road = np.dot(segmentation_other_road, np.array([[0, 0, 255, 127]]))\\n mask_other_road = scipy.misc.toimage(mask_other_road, mode=\\\"RGBA\\\")\\n \\n street_im = scipy.misc.toimage(image)\\n street_im.paste(mask_road, box=None, mask=mask_road)\\n street_im.paste(mask_other_road, box=None, mask=mask_other_road)\\n\\n yield os.path.basename(image_file), np.array(street_im)\",\n \"def process(self, step_guess_orientation=True, step_advanced_alignement=True,\\n step_gen_worldfiles=True, step_load_worldfiles=True,\\n step_gen_vrts=True, step_load_vrts=True,\\n step_load_debug=True ):\\n\\n QgsMessageLog.logMessage(\\\"1/ Instantiating all images...\\\", \\\"QuickDroneMap\\\", 0)\\n for root, dirs, files in os.walk(self.folder):\\n for file in files:\\n if file.endswith(\\\".jpg\\\") or file.endswith(\\\".JPG\\\"):\\n image_path = os.path.join(root, file)\\n image = Image(self, image_path)\\n self.images.append(image)\\n self.images = self.images[70:90]\\n # for i in [301,300,329]: # 3 images, transform fails on all of them\\n # for i in [397,398,364]: # 3 images, transform fails on one of them\\n # for i in [377,380,381]: # 3 images, transform works on all of them\\n # path = \\\"C:\\\\\\\\Users\\\\\\\\Olivier\\\\\\\\Dropbox\\\\\\\\Affaires\\\\\\\\SPC\\\\\\\\Sources\\\\\\\\quickdronemap\\\\\\\\test\\\\\\\\data\\\\\\\\DJI_{0:04d}.JPG\\\".format(i)\\n # self.images.append(Image(self, path))\\n\\n QgsMessageLog.logMessage(\\\"2/ Assigning ids\\\", \\\"QuickDroneMap\\\", 0)\\n for i, image in enumerate(self.images):\\n image.id = i\\n\\n\\n QgsMessageLog.logMessage(\\\"2/ Loading image attributes and parsing exif tags...\\\", \\\"QuickDroneMap\\\", 0)\\n for image in self.images:\\n image.set_attributes()\\n\\n if step_guess_orientation:\\n QgsMessageLog.logMessage(\\\"3/ Building image sequences...\\\", \\\"QuickDroneMap\\\", 0)\\n sorted_images = sorted(self.images, key=lambda x: x.timestamp)\\n for i in range(len(sorted_images)):\\n\\n prev_image = sorted_images[i-1] if i>0 else None\\n image = sorted_images[i]\\n next_image = sorted_images[i+1] if i<len(sorted_images)-1 else None\\n\\n if prev_image is None or next_image is None:\\n continue\\n\\n angle_p_i = math.atan2(image.point.x()-prev_image.point.x(),-image.point.y()+prev_image.point.y())\\n angle_i_n = math.atan2(next_image.point.x()-image.point.x(),-next_image.point.y()+image.point.y())\\n\\n # Checking if the three images are aligned (if not, we're probably at an angle)\\n dA = absolute_angle_difference(angle_p_i, angle_i_n)\\n if dA > ANGLE_THRESHOLD:\\n continue\\n\\n # Checking if the three images are near enough timewise, if not, it could be separate flights\\n dT1 = image.timestamp - prev_image.timestamp\\n dT2 = next_image.timestamp - image.timestamp\\n if dT1 > TIME_THRESHOLD or dT2 > TIME_THRESHOLD:\\n continue\\n\\n prev_image.next_image = image\\n image.prev_image = prev_image\\n image.next_image = next_image\\n next_image.prev_image = image\\n\\n QgsMessageLog.logMessage(\\\"4/ Deriving orientation from image sequence\\\", \\\"QuickDroneMap\\\", 0)\\n for image in self.images:\\n # if the direction wasn't set in the Exif tags, we derive it from the image sequences\\n if image.direction is None:\\n img_a = image.prev_image or image \\n img_b = image.next_image or image\\n image.angle = math.atan2(img_b.point.x()-img_a.point.x(),-img_b.point.y()+img_a.point.y())\\n\\n if step_advanced_alignement:\\n QgsMessageLog.logMessage(\\\"5/ Building image neighbourhood graph...\\\", \\\"QuickDroneMap\\\", 0)\\n from scipy.spatial import Delaunay\\n points = [(i.point.x(),i.point.y()) for i in self.images]\\n triangulation = Delaunay(points)\\n\\n done = [[False for _i2 in self.images] for _i1 in self.images]\\n for tri in triangulation.simplices:\\n i1,i2,i3 = tri\\n if not done[i1][i2]:\\n e = Edge(self.images[i1], self.images[i2])\\n self.edges.append(e)\\n self.images[i1].edges.append(e)\\n self.images[i2].edges.append(e)\\n done[i1][i2] = True\\n if not done[i1][i3]:\\n e = Edge(self.images[i1], self.images[i3])\\n self.edges.append(e)\\n self.images[i1].edges.append(e)\\n self.images[i3].edges.append(e)\\n done[i1][i3] = True\\n if not done[i2][i3]:\\n e = Edge(self.images[i2], self.images[i3])\\n self.edges.append(e)\\n self.images[i2].edges.append(e)\\n self.images[i3].edges.append(e)\\n done[i2][i3] = True\\n\\n QgsMessageLog.logMessage(\\\"6/ Computing similarities\\\", \\\"QuickDroneMap\\\", 0)\\n for i, edge in enumerate(self.edges):\\n QgsMessageLog.logMessage(\\\"Done {} out of {}\\\".format(i,len(self.edges)), \\\"QuickDroneMap\\\", 0)\\n QApplication.processEvents()\\n edge.compute_transform()\\n\\n # initial_guess_np, _ = self.get_initial_values_and_bounds()\\n # QgsMessageLog.logMessage(\\\"Initial fitness is {}\\\".format(self.calculate_fitness(initial_guess_np)), \\\"QuickDroneMap\\\", 0)\\n\\n # print(\\\"TESTING QUALITY OF SIMILARITY (disable optimization to do this)\\\")\\n # done = []\\n # edges_to_delete = []\\n # for edge in self.edges:\\n # QApplication.processEvents()\\n\\n # if edge.imageA in done or edge.imageB in done:\\n # edges_to_delete.append(edge)\\n # continue\\n\\n # done.append(edge.imageA)\\n # done.append(edge.imageB)\\n\\n # d_angle = edge.angle\\n # edge.imageB.angle = edge.imageA.angle + d_angle\\n\\n # f_scale = edge.scale\\n # edge.imageB.scale = edge.imageA.scale * f_scale\\n\\n # d_point = QgsPointXY(edge.tvec[0],edge.tvec[1])\\n # d_point = d_point.rotated(edge.imageA.angle)\\n # d_point *= edge.imageA.pixel_size/DOWNSCALING_FACTOR\\n # edge.imageB.point = edge.imageA.point + d_point\\n # for edge in edges_to_delete:\\n # self.edges.remove(edge)\\n\\n\\n # print(\\\"AFTER PROTOTYPE PLACEMENT\\\")\\n # initial_guess_np, _ = self.get_initial_values_and_bounds()\\n # self.calculate_fitness(initial_guess_np)\\n\\n\\n QgsMessageLog.logMessage(\\\"7/ Optimizing\\\", \\\"QuickDroneMap\\\", 0)\\n QApplication.processEvents()\\n\\n initial_guess_np, bounds = self.get_initial_values_and_bounds() \\n # res_1 = least_squares(calculate_fitness, initial_guess_np, bounds=([b[0] for b in bounds],[b[1] for b in bounds]))\\n res_1 = minimize(self.calculate_fitness, initial_guess_np, bounds=bounds)\\n\\n for image in self.images:\\n px = res_1.x[image.id*4+0]\\n py = res_1.x[image.id*4+1]\\n pa = res_1.x[image.id*4+2]\\n ps = res_1.x[image.id*4+3]\\n image.point = QgsPointXY(px, py)\\n image.angle = pa\\n image.psize = ps\\n\\n initial_guess_np, _ = self.get_initial_values_and_bounds()\\n QgsMessageLog.logMessage(\\\"After optimization fitness is {}\\\".format(self.calculate_fitness(initial_guess_np)), \\\"QuickDroneMap\\\", 0)\\n \\n QgsMessageLog.logMessage(\\\"8/ Computing all transforms...\\\", \\\"QuickDroneMap\\\", 0)\\n for image in self.images:\\n image.update_transform()\\n\\n if step_gen_worldfiles:\\n QgsMessageLog.logMessage(\\\"9a/ Creating and loading worldfiles\\\", \\\"QuickDroneMap\\\", 0)\\n for image in self.images:\\n image.write_worldfile()\\n if step_load_worldfiles:\\n image.load_worldfile(self.iface)\\n\\n if step_gen_vrts:\\n QgsMessageLog.logMessage(\\\"9b/ Creating and loading vrts\\\", \\\"QuickDroneMap\\\", 0)\\n for image in self.images:\\n image.write_vrt()\\n if step_load_vrts:\\n image.load_vrt(self.iface)\\n\\n if step_load_debug:\\n QgsMessageLog.logMessage(\\\"10/ Creating debug jsons files\\\", \\\"QuickDroneMap\\\", 0)\\n edg_data = {\\\"type\\\": \\\"FeatureCollection\\\",\\\"features\\\": [], \\\"crs\\\": {\\\"type\\\": \\\"EPSG\\\",\\\"properties\\\": {\\\"code\\\": 32628}}} # TODO : use self.crs\\n for edge in self.edges:\\n coords = [[edge.imageA.point.x(), edge.imageA.point.y()],[edge.imageB.point.x(), edge.imageB.point.y()]]\\n props = {k:v for (k,v) in vars(edge).items()}\\n props['angle_a'] = edge.imageA.angle\\n props['angle_b'] = edge.imageB.angle\\n feature = {\\\"type\\\": \\\"Feature\\\",\\\"properties\\\": props,\\\"geometry\\\": {\\\"type\\\": \\\"LineString\\\",\\\"coordinates\\\": coords}}\\n edg_data['features'].append(feature)\\n \\n edg_file = tempfile.NamedTemporaryFile(mode='w+', suffix='.geojson', delete=False)\\n json.dump(edg_data, edg_file, default=lambda o: str(o))\\n edg_file.close()\\n layer = self.iface.addVectorLayer(edg_file.name,\\\"[DEBUG] Edges\\\",\\\"ogr\\\")\\n layer.loadNamedStyle(os.path.join(os.path.dirname(os.path.realpath(__file__)),'debug_edges_style.qml'))\\n \\n graph_data = {\\\"type\\\": \\\"FeatureCollection\\\",\\\"features\\\": [], \\\"crs\\\": {\\\"type\\\": \\\"EPSG\\\",\\\"properties\\\": {\\\"code\\\": 4326}}} # TODO : use self.crs\\n for edge in self.edges:\\n coords = [[edge.imageA.lon, edge.imageA.lat],[edge.imageB.lon, edge.imageB.lat]]\\n props = {k:v for (k,v) in vars(edge).items()}\\n feature = {\\\"type\\\": \\\"Feature\\\",\\\"properties\\\": props,\\\"geometry\\\": {\\\"type\\\": \\\"LineString\\\",\\\"coordinates\\\": coords}}\\n graph_data['features'].append(feature)\\n\\n graph_file = tempfile.NamedTemporaryFile(mode='w+', suffix='.geojson', delete=False)\\n json.dump(graph_data, graph_file, default=lambda o: str(o))\\n graph_file.close()\\n layer = self.iface.addVectorLayer(graph_file.name,\\\"[DEBUG] Graph\\\",\\\"ogr\\\")\\n layer.loadNamedStyle(os.path.join(os.path.dirname(os.path.realpath(__file__)),'debug_graph_style.qml'))\",\n \"def sampleAndDownloadStreetImage(endPoints, sampleNum, picNum, ptrNum, targetDirectory, intersectionPointInfo):\\n print \\\"downloading street images...\\\"\\n sampledPoints = random.sample(endPoints, sampleNum) if sampleNum < len(endPoints) else endPoints\\n sampleData = [] # store (picture number, file name, lat and lng)\\n progress = Progress(10)\\n headings = CONFIG[\\\"gmap\\\"][\\\"headings\\\"]\\n sampleNumDelta = len(headings)\\n for point in sampledPoints:\\n progress.printProgress()\\n result = downloadSurroundingStreetView(point, targetDirectory, picNum, ptrNum, intersectionPointInfo)\\n sampleData += result\\n picNum += sampleNumDelta\\n ptrNum += 1\\n print \\\"\\\"\\n return sampleData\",\n \"def pick_triplets_images(images, n_triplets):\\n\\n indices = _pick_triplets(len(images), n_triplets)\\n\\n n_samples = len(indices)\\n\\n n_rows, n_cols, n_channels = images[0].shape\\n\\n images_samples = np.zeros((n_samples,n_rows, n_cols, n_channels), dtype = np.uint8)\\n\\n for i, index in enumerate(indices):\\n images_samples[i] = images[index]\\n\\n return images_samples\",\n \"def create_trials(self):\\n self.trial_list=[]\\n \\n #simple tools to check subject responses online\\n self.correct_responses = 0\\n self.total_responses = 0\\n self.dot_count = 0\\n \\n bar_orientations = np.array(self.settings['PRF stimulus settings']['Bar orientations'])\\n #create as many trials as TRs. 5 extra TRs at beginning + bar passes + blanks\\n self.trial_number = 5 + self.settings['PRF stimulus settings']['Bar pass steps']*len(np.where(bar_orientations != -1)[0]) + self.settings['PRF stimulus settings']['Blanks length']*len(np.where(bar_orientations == -1)[0])\\n \\n print(\\\"Expected number of TRs: %d\\\"%self.trial_number)\\n #create bar orientation list at each TR (this can be done in many different ways according to necessity)\\n #for example, currently blank periods have same length as bar passes. this can easily be changed here\\n steps_array=self.settings['PRF stimulus settings']['Bar pass steps']*np.ones(len(bar_orientations))\\n blanks_array=self.settings['PRF stimulus settings']['Blanks length']*np.ones(len(bar_orientations))\\n \\n repeat_times=np.where(bar_orientations == -1, blanks_array, steps_array).astype(int)\\n \\n self.bar_orientation_at_TR = np.concatenate((-1*np.ones(5), np.repeat(bar_orientations, repeat_times)))\\n \\n \\n #calculation of positions depend on whether code is run on mac\\n if self.settings['operating system'] == 'mac':\\n bar_pos_array = (self.win.size[1]/2)*np.linspace(-0.5,0.5, self.settings['PRF stimulus settings']['Bar pass steps'])\\n else:\\n bar_pos_array = self.win.size[1]*np.linspace(-0.5,0.5, self.settings['PRF stimulus settings']['Bar pass steps'])\\n \\n \\n blank_array = np.zeros(self.settings['PRF stimulus settings']['Blanks length'])\\n \\n #the 5 empty trials at beginning\\n self.bar_pos_in_ori=np.zeros(5)\\n \\n #bar position at TR\\n for i in range(len(bar_orientations)):\\n if bar_orientations[i]==-1:\\n self.bar_pos_in_ori=np.append(self.bar_pos_in_ori, blank_array)\\n else:\\n self.bar_pos_in_ori=np.append(self.bar_pos_in_ori, bar_pos_array)\\n \\n \\n #random bar direction at each step. could also make this time-based\\n self.bar_direction_at_TR = np.round(np.random.rand(self.trial_number))\\n \\n #trial list\\n for i in range(self.trial_number):\\n \\n self.trial_list.append(PRFTrial(session=self,\\n trial_nr=i,\\n \\n bar_orientation=self.bar_orientation_at_TR[i],\\n bar_position_in_ori=self.bar_pos_in_ori[i],\\n bar_direction=self.bar_direction_at_TR[i]\\n #,tracker=self.tracker\\n ))\\n\\n\\n #times for dot color change. continue the task into the topup\\n self.total_time = self.trial_number*self.bar_step_length \\n \\n if self.settings['mri']['topup_scan']==True:\\n self.total_time += self.topup_scan_duration\\n \\n \\n #DOT COLOR CHANGE TIMES \\n self.dot_switch_color_times = np.arange(3, self.total_time, float(self.settings['Task settings']['color switch interval']))\\n self.dot_switch_color_times += (2*np.random.rand(len(self.dot_switch_color_times))-1)\\n \\n \\n #needed to keep track of which dot to print\\n self.current_dot_time=0\\n self.next_dot_time=1\\n\\n #only for testing purposes\\n np.save(opj(self.output_dir, self.output_str+'_DotSwitchColorTimes.npy'), self.dot_switch_color_times)\\n print(self.win.size)\",\n \"def gen_ep_data(self,ntrials,trlen):\\n self.resort_emat()\\n ## instruction\\n # for each trial, generate random instruction encoding sequence\\n i_encoding_input = np.array([\\n np.random.permutation(np.arange(1,self.nmaps+1)) \\n for i in range(ntrials)\\n ])\\n i_test_input = np.zeros([ntrials,trlen])\\n i_input = np.concatenate([\\n i_encoding_input,i_test_input],\\n 1).astype(int).reshape(-1) # (ntrials,trlen+)\\n ## stimulus\\n x_encoding_input = i_encoding_input\\n x_test_input = np.random.randint(1,self.nmaps+1,[ntrials,trlen])\\n x_input = np.concatenate([x_encoding_input,x_test_input],1)\\n # print('X',x_input)\\n ''' \\n embed x_input: \\n [ntrials,nmaps+trlen] -> s_input [ntrials*(nmaps+trlen),edim]\\n explicit loop required for flatten and embedd x_input\\n because if switchmaps=1, matrix is resorted between trials\\n and therefore same stimulus token integers correspond to\\n different stimulus embeddings on different trials\\n '''\\n s_input = -np.ones([ntrials,(self.nmaps+trlen),self.stimdim])\\n for trialn,x_input_trial in enumerate(x_input): \\n if self.switchmaps: self.resort_emat()\\n s_input[trialn] = self.emat[x_input_trial]\\n # format output\\n i_input = tr.unsqueeze(tr.LongTensor(i_input),1)\\n s_input = tr.unsqueeze(tr.Tensor(np.concatenate(s_input)),1)\\n yseq = tr.unsqueeze(tr.LongTensor(x_input.reshape(-1)),1)\\n return i_input,s_input,yseq\",\n \"def _run_test(self):\\n scenes = [\\n \\\"../images/uturn_scene.jpg\\\",\\n \\\"../images/leftturn_scene.jpg\\\",\\n \\\"../images/rightturn_scene.jpg\\\"\\n ]\\n\\n for filename in scenes:\\n scene_img = cv2.imread(os.path.join(self.file_path, filename), 0)\\n pred = tm.predict(scene_img)\\n print filename.split('/')[-1]\\n print pred\",\n \"def save_test_images(images):\\n for description, img in images.items():\\n save_to_image(img, description)\\n save_to_netcdf(img, description)\",\n \"def upload_test_result_to_skia_gold(args, gold_session_manager, gold_session, gold_properties,\\n screenshot_dir, trace, artifacts):\\n\\n use_luci = not (gold_properties.local_pixel_tests or gold_properties.no_luci_auth)\\n\\n # Determine if this trace is using a keyframe\\n image_name = trace\\n keyframe = get_trace_key_frame(trace)\\n if keyframe != '':\\n image_name = trace + '_frame' + keyframe\\n logging.debug('Using %s as image_name for upload' % image_name)\\n\\n # Note: this would be better done by iterating the screenshot directory.\\n prefix = SWIFTSHADER_SCREENSHOT_PREFIX if args.swiftshader else DEFAULT_SCREENSHOT_PREFIX\\n png_file_name = os.path.join(screenshot_dir, prefix + image_name + '.png')\\n\\n if not os.path.isfile(png_file_name):\\n raise Exception('Screenshot not found: ' + png_file_name)\\n\\n if args.use_permissive_pixel_comparison:\\n # These arguments cause Gold to use the sample area inexact matching\\n # algorithm. It is set to allow any of up to 3 pixels in each 4x4 group\\n # of pixels to differ by any amount. Pixels that differ by a max of 1\\n # on all channels (i.e. have differences that can be attributed to\\n # rounding errors) do not count towards this limit.\\n #\\n # An image that passes due to this logic is auto-approved as a new good\\n # image.\\n inexact_matching_args = [\\n '--add-test-optional-key',\\n 'image_matching_algorithm:sample_area',\\n '--add-test-optional-key',\\n 'sample_area_width:4',\\n '--add-test-optional-key',\\n 'sample_area_max_different_pixels_per_area:3',\\n '--add-test-optional-key',\\n 'sample_area_channel_delta_threshold:1',\\n ]\\n else:\\n # These arguments cause Gold to use the fuzzy inexact matching\\n # algorithm. It is set to allow up to 20k pixels to differ by 1 on all\\n # channels, which is meant to help reduce triage overhead caused by new\\n # images from rounding differences.\\n #\\n # The max number of pixels is fairly arbitrary, but the diff threshold\\n # is intentional since we don't want to let in any changes that can't be\\n # attributed to rounding errors.\\n #\\n # An image that passes due to this logic is auto-approved as a new good\\n # image.\\n inexact_matching_args = [\\n '--add-test-optional-key',\\n 'image_matching_algorithm:fuzzy',\\n '--add-test-optional-key',\\n 'fuzzy_max_different_pixels:20000',\\n '--add-test-optional-key',\\n 'fuzzy_pixel_per_channel_delta_threshold:1',\\n ]\\n\\n status, error = gold_session.RunComparison(\\n name=image_name,\\n png_file=png_file_name,\\n use_luci=use_luci,\\n inexact_matching_args=inexact_matching_args)\\n\\n artifact_name = os.path.basename(png_file_name)\\n artifacts[artifact_name] = [artifact_name]\\n\\n if not status:\\n return PASS\\n\\n status_codes = gold_session_manager.GetSessionClass().StatusCodes\\n if status == status_codes.AUTH_FAILURE:\\n logging.error('Gold authentication failed with output %s', error)\\n elif status == status_codes.INIT_FAILURE:\\n logging.error('Gold initialization failed with output %s', error)\\n elif status == status_codes.COMPARISON_FAILURE_REMOTE:\\n _, triage_link = gold_session.GetTriageLinks(image_name)\\n if not triage_link:\\n logging.error('Failed to get triage link for %s, raw output: %s', image_name, error)\\n logging.error('Reason for no triage link: %s',\\n gold_session.GetTriageLinkOmissionReason(image_name))\\n if gold_properties.IsTryjobRun():\\n # Pick \\\"show all results\\\" so we can see the tryjob images by default.\\n triage_link += '&master=true'\\n artifacts['triage_link_for_entire_cl'] = [triage_link]\\n else:\\n artifacts['gold_triage_link'] = [triage_link]\\n elif status == status_codes.COMPARISON_FAILURE_LOCAL:\\n logging.error('Local comparison failed. Local diff files:')\\n output_diff_local_files(gold_session, image_name)\\n elif status == status_codes.LOCAL_DIFF_FAILURE:\\n logging.error(\\n 'Local comparison failed and an error occurred during diff '\\n 'generation: %s', error)\\n # There might be some files, so try outputting them.\\n logging.error('Local diff files:')\\n output_diff_local_files(gold_session, image_name)\\n else:\\n logging.error('Given unhandled SkiaGoldSession StatusCode %s with error %s', status, error)\\n\\n return FAIL\",\n \"def generate_test_set(data, pts): \\n test_set = np.asarray(random.sample(data, pts))\\n \\n return test_set\",\n \"def test_ANTSRegistrationRPT(self):\\n ants_rpt = ANTSRegistrationRPT(\\n generate_report=True, moving_image=self.moving, fixed_image=self.reference,\\n from_file=pkgr.resource_filename(\\n 'niworkflows.data', 't1-mni_registration_testing_000.json'))\\n _smoke_test_report(ants_rpt, 'testANTSRegistrationRPT.svg')\",\n \"def _generate_input_tuple(self, data_element):\\n itk_img = sitk.ReadImage(os.path.join(os.path.join(self.base_path, 'images'), data_element))\\n itk_centroid = sitk.ReadImage(os.path.join(os.path.join(self.base_path, 'centroid_masks'), data_element))\\n \\n itk_img_arr = np.array(sitk.GetArrayFromImage(itk_img))\\n itk_centroid_arr = sitk.GetArrayFromImage(itk_centroid)\\n\\n itk_ref_img = sitk.ReadImage(os.path.join(os.path.join(self.base_path, 'images'), 'verse004.mha'))\\n itk_ref_img_arr = np.array(sitk.GetArrayFromImage(itk_ref_img))\\n\\n itk_hist_img = histogram_match(itk_img_arr, itk_ref_img_arr)\\n \\n # the augmentation carrousel\\n apply_flip = random.choice([True, False])\\n rot_range = 30\\n shift_range = 30\\n stretch_range = [1.1, 1.5, 2]\\n rand_rotate_angle = random.randint( -rot_range, rot_range)\\n rand_shift_distance = random.randint( -shift_range, shift_range)\\n for i, fac in enumerate(stretch_range):\\n my_fac = random.randint( 0, round((fac - 1) * 10))/10\\n rand_factor = 1 + my_fac\\n stretch_range[i] = rand_factor\\n rand_axis_rotate = random.randint(0,2)\\n rand_axis_shift = random.randint(0,2)\\n\\n # Image is resized here, but heatmaps are resized to corresponding shape since the resize messes with the label values\\n\\n itk_img_resize = transform.resize(itk_hist_img, self.input_shape, mode='edge')\\n \\n itk_img_aug = augment_flip(itk_img_resize, apply_flip)\\n itk_img_aug = augment_rotate(itk_img_aug, rand_axis_rotate, rand_rotate_angle)\\n itk_img_aug = augment_shift(itk_img_aug, rand_axis_shift, rand_shift_distance)\\n itk_img_aug = augment_stretch(itk_img_aug, stretch_factors=stretch_range)\\n\\n itk_img_arr_resize = transform.resize(itk_hist_img, self.input_shape, mode='edge')\\n \\n heatmap = generate_heatmap(itk_centroid_arr, self.input_shape, self.n_classes, debug=False)\\n # augment heatmap likewise\\n for i in range(self.n_classes):\\n heatmap[i] = augment_flip(heatmap[i], apply_flip)\\n heatmap[i] = augment_rotate(heatmap[i], rand_axis_rotate, rand_rotate_angle)\\n heatmap[i] = augment_shift(heatmap[i], rand_axis_shift, rand_shift_distance)\\n heatmap[i] = augment_stretch(heatmap[i], stretch_factors=stretch_range)\\n\\n heatmap = np.moveaxis(heatmap, 0, -1)\\n # return (itk_img_arr_resize, heatmap)\\n return (itk_img_aug, heatmap)\",\n \"def match_based_on_spatial_temperal_prior_test_2(tracker_record_1, tracker_record_2, pt_obj_1, pt_obj_2, associate_dict, t_interval=30):\\n print(\\\"===== Get in the match_based_on_spatial_temperal_prior_test_2! ===== \\\")\\n \\n # file path\\n device_id_1 = 0\\n device_id_2 = 1\\n img_root_1 = data_path[device_id_1]\\n img_root_2 = data_path[device_id_2]\\n # save_root =\\n \\n obj_single_camera_stp_cam_1 = SingleCameraSTP(tracker_record_1, pt_obj_1)\\n obj_single_camera_stp_cam_2 = SingleCameraSTP(tracker_record_2, pt_obj_2)\\n \\n print(obj_single_camera_stp_cam_1.perspective_trace)\\n print(obj_single_camera_stp_cam_1.motion_params_4_each)\\n obj_multi_cameras_stp_c1c2 = MultiCamerasSTP(\\n obj_single_camera_stp_cam_1,\\n obj_single_camera_stp_cam_2,\\n associate_dict)\\n\\n # # ===== TEST:coord_transformer_test =====\\n # coord_transformer_test(obj_multi_cameras_stp_c1c2)\\n # obj_multi_cameras_stp_c1c2.get_start_point_transform()\\n \\n pt_box_info_1 = obj_multi_cameras_stp_c1c2.obj_single_camera_stp_cam_1.perspective_trace\\n pt_box_info_2 = obj_multi_cameras_stp_c1c2.obj_single_camera_stp_cam_2.perspective_trace\\n \\n # Test on object id '1'\\n object_id = '0'\\n \\n for i in range(np.min([len(pt_box_info_1[object_id]), len(pt_box_info_2[object_id])])):\\n f1 = i\\n f2 = i\\n fname_1 = str(pt_box_info_1[object_id][f1][1])+'.jpg'\\n fname_2 = str(pt_box_info_2[object_id][f2][1])+'.jpg'\\n \\n img_1 = cv2.imread(os.path.join(img_root_1, fname_1))\\n img_2 = cv2.imread(os.path.join(img_root_2, fname_2))\\n \\n cam_1_x = pt_box_info_1[object_id][f1][0][0]\\n cam_1_y = pt_box_info_1[object_id][f1][0][1]\\n \\n cam_2_x = pt_box_info_2[object_id][f2][0][0]\\n cam_2_y = pt_box_info_2[object_id][f2][0][1]\\n \\n t_interval = pt_box_info_2[object_id][f2][1]-pt_box_info_1[object_id][f1][1]\\n \\n print(cam_1_x, cam_1_y)\\n print(cam_2_x, cam_2_y)\\n print(t_interval)\\n # print(obj_multi_cameras_stp_c1c2.starting_point)\\n \\n p_map = obj_multi_cameras_stp_c1c2.get_probability_map(cam_1_x, cam_1_y, t_interval, height=210, width=80)\\n p_map = cv2.applyColorMap(p_map, cv2.COLORMAP_JET)\\n p = obj_multi_cameras_stp_c1c2.get_probability(cam_2_x, cam_2_y, cam_1_x, cam_1_y, t_interval)\\n print(p)\\n # dist = obj_multi_cameras_stp_c1c2.get_distance(cam_2_x,cam_2_y,cam_1_x,cam_1_y,t_interval)\\n p_map = cv2.resize(p_map, (int(pt_obj_2.transformed_width_for_disp), int(pt_obj_2.transformed_height_for_disp)))\\n p_map = cv2.flip(p_map, 0) # 0:vertical flip\\n pt_color_p_map = pt_obj_2.get_inverse_disp_transform(p_map)\\n \\n alpha = 0.5\\n img_3 = cv2.addWeighted(img_2, alpha, pt_color_p_map, 1-alpha, 0)\\n \\n img_4 = np.zeros((int(img_2.shape[0]), int(img_2.shape[1]*2), 3), np.uint8)\\n img_4[:, :img_1.shape[1], :] = img_1\\n img_4[:, img_1.shape[1]:, :] = img_3\\n\\n # cv2.namedWindow('img_1',cv2.WINDOW_NORMAL)\\n # cv2.namedWindow('img_2',cv2.WINDOW_NORMAL)\\n cv2.namedWindow('img_4', cv2.WINDOW_NORMAL)\\n \\n # cv2.imshow('img_1',img_1)\\n # cv2.imshow('img_2',img_2)\\n cv2.imshow('img_4', img_4)\\n \\n cv2.imwrite(os.path.join(save_root, fname_1), img_4)\\n \\n cv2.waitKey()\\n return\",\n \"def generateArmMapping(inner_domain_shape, env, trials=1000, stime=50):\\n # build dataset\\n try:\\n data = np.load(\\\"data/StoredArmGenerateData.npy\\\")\\n except IOError:\\n data = getData(trials, stime, env)\\n # train SOM\\n weights = generatePrototypes(data, inner_domain_shape)\\n return weights\",\n \"def gen_latent( model, dset, data_class ):\\n dd = {}\\n\\n for dpath, dnames, fnames in os.walk( dset ):\\n for f in fnames:\\n if f.endswith( '.jpg' ) and data_class in f:\\n n = f.split( '.' )[ 0 ] # code name of frame\\n l = ts.pred_image( model, os.path.join( dpath, f ) ) # output of encoder\\n dd[ n ] = l\\n if DEBUG: print( n )\\n\\n return dd\",\n \"def gen_ep_data(self,num_trials=1,trial_len=20,pm_probe_positions=None):\\n # insert extra positive trials than expected by chance\\n pos_og_bias=np.random.randint(1,100,1)\\n # initialize returnables\\n ep_len = num_trials*(trial_len+self.nmaps)\\n inst_seq = -np.ones([ep_len])\\n stim_seq = -np.ones([ep_len,self.sdim])\\n action_seq = -np.ones([ep_len])\\n\\n # loop over trails\\n for trial in range(num_trials):\\n ## randomize emats\\n self.shuffle_pms()\\n # generate trial idx_seq\\n inst_stim_seq_int,inst_action_seq_int = self.gen_trial_inst_phase()\\n resp_stim_seq_int,resp_action_seq_int = self.gen_trial_resp_phase(\\n trial_len,pos_og_bias,pm_probe_positions)\\n # embed stim idx_seq\\n inst_stim_seq = self.emat[inst_stim_seq_int]\\n resp_stim_seq = self.emat[resp_stim_seq_int]\\n # collect\\n t0 = trial*(trial_len+self.nmaps)\\n t1 = t0+trial_len+self.nmaps\\n inst_seq[t0:t1] = np.concatenate([inst_stim_seq_int,np.zeros(trial_len)],axis=0)\\n stim_seq[t0:t1] = np.concatenate([inst_stim_seq,resp_stim_seq],axis=0)\\n action_seq[t0:t1] = np.concatenate([inst_action_seq_int,resp_action_seq_int],axis=0)\\n inst_seq = tr.LongTensor(inst_seq).unsqueeze(1) # batch dim\\n stim_seq = tr.Tensor(stim_seq).unsqueeze(1) \\n action_seq = tr.LongTensor(action_seq).unsqueeze(1) \\n return inst_seq,stim_seq,action_seq\",\n \"def __call__(self, sample):\\n image, landmarks = sample['image'], sample['landmarks']\\n choices = ((0, 1, 2), (0, 2, 1), (1, 0, 2),\\n (1, 2, 0), (2, 1, 0), (2, 0, 1))\\n p = random.random()\\n if p <= 0.5:\\n idx = random.randint(0, 5)\\n swap = choices[idx]\\n image = image[:, :, swap]\\n return {'image': image,\\n 'landmarks': landmarks}\",\n \"def cutTiles(tasksInfo, results, origLocation, destLocation, \\\\\\n completedOnly, nAnswers = 0):\\n tmpMosaic = destLocation+\\\"/tmpMosaic_n\\\"+str(nAnswers)+\\\"/\\\"\\n createDir(tmpMosaic)\\n\\n #Setting info on images\\n numberImages = 12\\n tmpImg = []\\n for i in range(numberImages):\\n tmpImg.append(destLocation+\\\"/tmpImg_n\\\"+str(i+1).zfill(2)+\\\"/\\\")\\n createDir(tmpImg[i])\\n imgFile = []\\n imgFile.append('2011352')\\n imgFile.append('2011353')\\n imgFile.append('2011355')\\n imgFile.append('2011357')\\n imgFile.append('2011358')\\n imgFile.append('2011359')\\n imgFile.append('2011360')\\n imgFile.append('2011361')\\n imgFile.append('2011362')\\n imgFile.append('2011363')\\n imgFile.append('2011364')\\n imgFile.append('2011365')\\n\\n #Setting info on image type\\n formatFile = \\\"GTiff\\\"\\n driver = gdal.GetDriverByName(formatFile)\\n\\n #Open file containing geoinfo on best result and statistical info on all\\n if completedOnly == 1:\\n f = open(destLocation+'/bestInfo.txt','w')\\n #~ fStat = open(destLocation+'/statInfoCompleted.txt','w')\\n #~ else:\\n #~ fStat = open(destLocation+'/statInfoAll_n'+str(nAnswers)+'.txt','w')\\n\\n fSelect = open(destLocation+'/selectedTile.txt','w')\\n numberTasks = len(tasksInfo)\\n print 'tasksInfo: ', len(tasksInfo)\\n print 'results: ', len(results)\\n for task in range(numberTasks):\\n #Checking if the task has the mininum number of answers\\n if (sum(results[task]) < nAnswers):\\n #If it has not, lets go to the next task\\n continue\\n #Geting the selected day for each task\\n taskId = tasksInfo[task]['taskId']\\n definedArea = tasksInfo[task]['area']\\n selectedTile = results[task].index(max(results[task]))\\n if selectedTile == 0:\\n selectedFile = '2011352'\\n elif selectedTile == 1:\\n selectedFile = '2011353'\\n elif selectedTile == 2:\\n selectedFile = '2011355'\\n elif selectedTile == 3:\\n selectedFile = '2011357'\\n elif selectedTile == 4:\\n selectedFile = '2011358'\\n elif selectedTile == 5:\\n selectedFile = '2011359'\\n elif selectedTile == 6:\\n selectedFile = '2011360'\\n elif selectedTile == 7:\\n selectedFile = '2011361'\\n elif selectedTile == 8:\\n selectedFile = '2011362'\\n elif selectedTile == 9:\\n selectedFile = '2011363'\\n elif selectedTile == 10:\\n selectedFile = '2011364'\\n elif selectedTile == 11:\\n selectedFile = '2011365'\\n print taskId\\n print selectedFile\\n print definedArea\\n fSelect.write(str(taskId)+\\\" \\\"+selectedFile+\\\"\\\\n\\\")\\n #Printing bestInfo\\n if completedOnly == 1:\\n f.write(str(definedArea[0])+\\\" \\\"+ str(definedArea[1])+\\\" \\\"+\\\\\\n str(definedArea[2])+\\\" \\\"+str(definedArea[3])+\\\"\\\\n\\\")\\n cmd = \\\"gdal_translate -projwin \\\"+str(definedArea[0])+\\\" \\\"+ \\\\\\n str(definedArea[3])+\\\" \\\"+str(definedArea[2])+\\\" \\\"+ \\\\\\n str(definedArea[1])+\\\" \\\"+origLocation+selectedFile+\\\".tif \\\"+ \\\\\\n tmpMosaic+str(taskId)+\\\".tif\\\"\\n os.system(cmd)\\n #Generating image cuts for all images\\n for i in range(numberImages):\\n cmd = \\\"gdal_translate -projwin \\\"+str(definedArea[0])+\\\" \\\"+ \\\\\\n str(definedArea[3])+\\\" \\\"+str(definedArea[2])+\\\" \\\"+ \\\\\\n str(definedArea[1])+\\\" \\\"+origLocation+imgFile[i]+\\\".tif \\\"+ \\\\\\n tmpImg[i]+str(taskId)+\\\".tif\\\"\\n os.system(cmd)\\n #Changing filename based on the type of result (if all results or\\n #completed only.\\n if completedOnly == 0:\\n if nAnswers == 0:\\n fileMosaic = \\\"mosaicall\\\"\\n else:\\n fileMosaic = \\\"mosaicall\\\"+\\\"_n\\\"+str(nAnswers)\\n elif completedOnly == 1:\\n if nAnswers == 0:\\n fileMosaic = \\\"mosaiccompleted\\\"\\n else:\\n fileMosaic = \\\"mosaiccompleted\\\"+\\\"_n\\\"+str(nAnswers)\\n #Checking if the temporary tile folder is not empty\\n if os.listdir(tmpMosaic) == []:\\n print \\\"No output detected for desired parameter N = \\\" + str(nAnswers)\\n #Removing temporary directories\\n removeDir(tmpMosaic)\\n #Returning error code\\n resultCut = 1\\n return resultCut\\n #Merging the tiles into one mosaic\\n cmd = \\\"gdal_merge.py -init '200 200 200' -o \\\"+destLocation+fileMosaic+\\\".tif \\\"+tmpMosaic+ \\\\\\n \\\"*.tif\\\"\\n os.system(cmd)\\n #Copying file with timestamp\\n now = datetime.datetime.now()\\n timeCreation = now.strftime(\\\"%Y-%m-%d_%Hh%M\\\")\\n shutil.copyfile(destLocation+fileMosaic+\\\".tif\\\", destLocation+ \\\\\\n fileMosaic+\\\"_\\\"+timeCreation+\\\".tif\\\")\\n #Close file containing geoinfo on best result\\n if completedOnly == 1:\\n f.close()\\n #Close stat file\\n #~ fStat.close()\\n fSelect.close()\\n #Removing temporary directories\\n #~ removeDir(tmpMosaic)\\n #~ for i in range(numberImg):\\n #~ removeDir(tmpImg[i])\\n #Final state\\n resultCut = 0\\n return resultCut\",\n \"def _get_test_generator(self):\\n for data_element in self.test:\\n image, heatmap = self._generate_input_tuple(data_element)\\n \\n yield (image, heatmap)\",\n \"def sample_images(batches_done):\\n imgs = next(iter(val_dataloader))\\n G_AB.eval()\\n G_BA.eval()\\n real_A = Variable(imgs[\\\"A\\\"].type(Tensor))\\n fake_B = G_AB(real_A)\\n real_B = Variable(imgs[\\\"B\\\"].type(Tensor))\\n fake_A = G_BA(real_B)\\n # Arrange images along x-axis\\n real_A = make_grid(real_A[:3,:,:,:], nrow=3, normalize=True)\\n real_B = make_grid(real_B[:3,:,:,:], nrow=3, normalize=True)\\n fake_A = make_grid(fake_A[:3,:,:,:], nrow=3, normalize=True)\\n fake_B = make_grid(fake_B[:3,:,:,:], nrow=3, normalize=True)\\n # Arrange images along y-axis\\n image_grid = torch.cat((real_A, fake_B, real_B, fake_A), 1)\\n save_image(image_grid, \\\"/content/drive/MyDrive/Night2Day/images/generated_4/%s.png\\\" % (batches_done), normalize=False)\",\n \"def shootout_ran():\\r\\n return choice([\\r\\n \\\"https://im-a-dev.xyz/QqoZ2M6m.png\\\",\\r\\n \\\"https://im-a-dev.xyz/BvdekLII.png\\\",\\r\\n \\\"https://im-a-dev.xyz/MfSnYYAa.png\\\"\\r\\n ])\",\n \"def generate_overview_tiles(self):\\n\\n gdal.SetConfigOption(\\\"GDAL_PAM_ENABLED\\\", \\\"NO\\\")\\n\\n print \\\"Generating Overview Tiles:\\\"\\n\\n if self.options.profile == 'garmin': # no overview tiles for 'garmin'\\n return\\n # Usage of existing tiles: from 4 underlying tiles generate one as overview.\\n\\n tcount = 0\\n zcount = 0\\n for tz in range(self.tmaxz-1, self.tminz-1, -1):\\n tminx, tminy, tmaxx, tmaxy = self.tminmax[tz]\\n tcount += (1+abs(tmaxx-tminx)) * (1+abs(tmaxy-tminy))\\n zcount+=1\\n if self.options.resume:\\n count_tiles=tcount\\n zcount+=1\\n tminx, tminy, tmaxx, tmaxy = self.tminmax[self.tmaxz]\\n count_tiles += (1+abs(tmaxx-tminx)) * (1+abs(tmaxy-tminy))\\n i_count = self.tile_exists(0, 0, 0,1)\\n if i_count == count_tiles:\\n if self.options.verbose:\\n print \\\"\\\\tTile generation skipped because of --resume ; all-tiles [\\\",zcount,\\\"] zoom-levels with tiles[\\\",count_tiles,\\\"]\\\"\\n return\\n ti = 0\\n\\n # querysize = tilesize * 2\\n\\n for tz in range(self.tmaxz-1, self.tminz-1, -1):\\n tminx, tminy, tmaxx, tmaxy = self.tminmax[tz]\\n i_x_column_count=((tmaxx-tminx)+1)\\n i_y_column_count=((tmaxy-tminy)+1)\\n if self.options.verbose:\\n # tx in range(tminx, tmaxx+1) tminx[ 140798 ] tmaxx[ 140872 ] ; ((tmaxx-tmaxy)+1) x_tiles[ -35331 ]\\n print \\\"\\\\ttz=[\\\",tz,\\\"] : tx in range(tminx, tmaxx+1) tminx[\\\",tminx,\\\"] tmaxx[\\\",tmaxx,\\\"] ; ((tmaxx-tminx)+1) x_tiles[\\\",i_x_column_count,\\\"]\\\"\\n # ty_tms in range(tmaxy, tminy-1, -1) tmaxy[ 176204 ] tminy[ 176126 ] ; ((tmaxy-tminy)) y_tiles[ 78 ]\\n print \\\"\\\\ttz=[\\\",tz,\\\"] :ty_tms in range(tmaxy, tminy-1, -1) tmaxy[\\\",tmaxy,\\\"] tminy[\\\",tminy,\\\"] ; ((tmaxy-tminy)) y_tiles[\\\",i_y_column_count,\\\"]\\\"\\n if self.options.resume:\\n i_count = self.tile_exists(0, 0, tz,2)\\n print \\\"\\\\tTile generation skipped because of --??? ; x/y-tiles of z[\\\",tz,\\\"] x/y_tiles[\\\",tcount,\\\"] i_count[\\\",i_count,\\\"]\\\"\\n if i_count == tcount:\\n if self.options.verbose:\\n print \\\"\\\\tTile generation skipped because of --resume ; x/y-tiles of z[\\\",tz,\\\"] x/y_tiles[\\\",tcount,\\\"]\\\"\\n break\\n for tx in range(tminx, tmaxx+1):\\n tmaxy_work=tmaxy\\n if self.options.resume:\\n i_count = self.tile_exists(tx, 0, tz,3)\\n print \\\"\\\\tTile generation skipped because of --??? ; z =\\\",tz,\\\" ; y-tiles of x[\\\",tx,\\\"] y_tiles[\\\",i_y_column_count,\\\"] i_count[\\\",i_count,\\\"]\\\"\\n if i_count == i_y_column_count:\\n if self.options.verbose:\\n print \\\"\\\\tTile generation skipped because of --resume ; z =\\\",tz,\\\" ; y-tiles of x[\\\",tx,\\\"] y_tiles[\\\",i_y_column_count,\\\"]\\\"\\n break\\n else:\\n if i_count > 0:\\n # this assums the rows are compleate, which may NOT be true 18-140798-176204.jpg\\n tmaxy_work-=i_count\\n if self.options.verbose:\\n print \\\"\\\\tTile generation skipped to tmaxy[\\\",tmaxy_work,\\\"] because of --resume ; z =\\\",tz,\\\" ; y-tiles of x[\\\",tx,\\\"] y_tiles[\\\",i_y_column_count,\\\"]\\\"\\n for ty_tms in range(tmaxy_work, tminy-1, -1): #range(tminy, tmaxy+1):\\n ty_osm=self.flip_y(tz,ty_tms)\\n ty=ty_tms\\n if self.options.tms_osm:\\n ty=ty_osm\\n if self.stopped:\\n if self.options.mbtiles:\\n if self.mbtiles_db:\\n self.mbtiles_db.close_db()\\n self.mbtiles_db=None\\n break\\n\\n ti += 1\\n\\n if self.options.resume:\\n exists = self.tile_exists(tx, ty, tz,0)\\n if exists and self.options.verbose:\\n print \\\"\\\\tTile generation skipped because of --resume\\\"\\n else:\\n exists = False\\n\\n if not exists:\\n if self.options.verbose:\\n print ti, '/', tcount, self.get_verbose_tile_name(tx, ty, tz)\\n try:\\n self.write_overview_tile(tx, ty, tz,self.options.tms_osm)\\n except ImageOutputException, e:\\n self.error(\\\"'%d/%d/%d': %s\\\" % (tz, tx, ty, e.message))\\n\\n if not self.options.verbose or self.is_subprocess:\\n self.progressbar( ti / float(tcount) )\\n if self.options.mbtiles:\\n if self.mbtiles_db:\\n self.mbtiles_db.close_db()\\n self.mbtiles_db=None\",\n \"def tempmap():\\n rand_number = [random.randint(0, 9) for i in range(6)]\\n rand_number_str = ''.join(map(str, rand_number))\\n mapname = 'temp_' + rand_number_str\\n maplist = grass.read_command('g.list', type='vector', mapset='.').split()\\n while mapname in maplist:\\n rand_number = [random.randint(0, 9) for i in range(6)]\\n rand_number_str = ''.join(map(str, rand_number))\\n mapname = 'temp_' + rand_number_str\\n maplist = grass.read_command('g.list', type='vector', mapset='.').split()\\n return mapname\",\n \"def create_GT_masks(root_dir, background_dir, intrinsic_matrix,classes):\\n list_all_images = load_obj(root_dir + \\\"all_images_adr\\\")\\n training_images_idx = load_obj(root_dir + \\\"train_images_indices\\\")\\n for i in range(len(training_images_idx)):\\n img_adr = list_all_images[training_images_idx[i]]\\n label = os.path.split(os.path.split(os.path.dirname(img_adr))[0])[1]\\n regex = re.compile(r'\\\\d+')\\n idx = regex.findall(os.path.split(img_adr)[1])[0]\\n\\n if i % 1000 == 0:\\n print(str(i) + \\\"/\\\" + str(len(training_images_idx)) + \\\" finished!\\\")\\n\\n image = cv2.imread(img_adr)\\n ID_mask = np.zeros((image.shape[0], image.shape[1]))\\n U_mask = np.zeros((image.shape[0], image.shape[1]))\\n V_mask = np.zeros((image.shape[0], image.shape[1]))\\n\\n ID_mask_file = root_dir + label + \\\\\\n \\\"/ground_truth/IDmasks/color\\\" + str(idx) + \\\".png\\\"\\n U_mask_file = root_dir + label + \\\\\\n \\\"/ground_truth/Umasks/color\\\" + str(idx) + \\\".png\\\"\\n V_mask_file = root_dir + label + \\\\\\n \\\"/ground_truth/Vmasks/color\\\" + str(idx) + \\\".png\\\"\\n\\n tra_adr = root_dir + label + \\\"/data/tra\\\" + str(idx) + \\\".tra\\\"\\n rot_adr = root_dir + label + \\\"/data/rot\\\" + str(idx) + \\\".rot\\\"\\n rigid_transformation = get_rot_tra(rot_adr, tra_adr)\\n\\n # Read point Point Cloud Data\\n ptcld_file = root_dir + label + \\\"/object.xyz\\\"\\n pt_cld_data = np.loadtxt(ptcld_file, skiprows=1, usecols=(0, 1, 2))\\n ones = np.ones((pt_cld_data.shape[0], 1))\\n homogenous_coordinate = np.append(pt_cld_data[:, :3], ones, axis=1)\\n\\n # Perspective Projection to obtain 2D coordinates for masks\\n homogenous_2D = intrinsic_matrix @ (rigid_transformation @ homogenous_coordinate.T)\\n coord_2D = homogenous_2D[:2, :] / homogenous_2D[2, :]\\n coord_2D = ((np.floor(coord_2D)).T).astype(int)\\n x_2d = np.clip(coord_2D[:, 0], 0, 639)\\n y_2d = np.clip(coord_2D[:, 1], 0, 479)\\n ID_mask[y_2d, x_2d] = classes[label]\\n\\n if i % 100 != 0: # change background for every 99/100 images\\n background_img_adr = background_dir + random.choice(os.listdir(background_dir))\\n background_img = cv2.imread(background_img_adr)\\n background_img = cv2.resize(background_img, (image.shape[1], image.shape[0]), interpolation=cv2.INTER_AREA)\\n background_img[y_2d, x_2d, :] = image[y_2d, x_2d, :]\\n background_adr = root_dir + label + \\\"/changed_background/color\\\" + str(idx) + \\\".png\\\"\\n mpimg.imsave(background_adr, background_img)\\n\\n # Generate Ground Truth UV Maps\\n centre = np.mean(pt_cld_data, axis=0)\\n length = np.sqrt((centre[0]-pt_cld_data[:, 0])**2 + (centre[1] -\\n pt_cld_data[:, 1])**2 + (centre[2]-pt_cld_data[:, 2])**2)\\n unit_vector = [(pt_cld_data[:, 0]-centre[0])/length, (pt_cld_data[:,\\n 1]-centre[1])/length, (pt_cld_data[:, 2]-centre[2])/length]\\n U = 0.5 + (np.arctan2(unit_vector[2], unit_vector[0])/(2*np.pi))\\n V = 0.5 - (np.arcsin(unit_vector[1])/np.pi)\\n U_mask[y_2d, x_2d] = U\\n V_mask[y_2d, x_2d] = V\\n\\n # Saving ID, U and V masks after using the fill holes function\\n ID_mask, U_mask, V_mask = fill_holes(ID_mask, U_mask, V_mask)\\n cv2.imwrite(ID_mask_file, ID_mask)\\n mpimg.imsave(U_mask_file, U_mask, cmap='gray')\\n mpimg.imsave(V_mask_file, V_mask, cmap='gray')\",\n \"def createTrialBatchesWithDynamics((taskRuleSet,nTasks,shuffle,batchNum)):\\n if batchNum%100==0:\\n print 'Running batch', batchNum\\n\\n nMiniblocks = nTasks\\n nTasks = nTasks # Corresponds to the number of miniblocks\\n n_trials_per_block = 3\\n shuffle=True\\n \\n stimuliSet = task.createSensoryInputs()\\n\\n networkIO_DataFrame = {}\\n networkIO_DataFrame['LogicRule'] = []\\n networkIO_DataFrame['SensoryRule'] = []\\n networkIO_DataFrame['MotorRule'] = []\\n networkIO_DataFrame['Color1'] = []\\n networkIO_DataFrame['Color2'] = []\\n networkIO_DataFrame['Orientation1'] = []\\n networkIO_DataFrame['Orientation2'] = []\\n networkIO_DataFrame['Pitch1'] = []\\n networkIO_DataFrame['Pitch2'] = []\\n networkIO_DataFrame['Constant1'] = []\\n networkIO_DataFrame['Constant2'] = []\\n networkIO_DataFrame['MotorResponse'] = []\\n\\n # Create 1d array to randomly sample indices from\\n stimIndices = np.arange(len(stimuliSet))\\n taskIndices = np.arange(len(taskRuleSet))\\n \\n randomTaskIndices = np.random.choice(taskIndices,nTasks,replace=False)\\n taskRuleSet2 = taskRuleSet.iloc[randomTaskIndices].copy(deep=True)\\n taskRuleSet2 = taskRuleSet2.reset_index(drop=True)\\n taskRuleSet = taskRuleSet2.copy(deep=True)\\n\\n# networkInputCode = []\\n# networkOutputCode = []\\n# for taskrule in taskRuleSet.index:\\n# \\n# randomStimuliIndices = np.random.choice(stimIndices,n_trials_per_block,replace=False)\\n# stimuliSet2 = stimuliSet.iloc[randomStimuliIndices].copy(deep=True)\\n# stimuliSet2 = stimuliSet2.reset_index(drop=True)\\n# \\n# for trial in stimuliSet2.index:\\n#\\n# networkInputCode.append(np.hstack((taskRuleSet.Code[taskrule], stimuliSet2.Code[trial])))\\n# tmpresp, tmpcode = task.solveInputs(taskRuleSet.iloc[taskrule], stimuliSet2.iloc[trial])\\n# networkOutputCode.append(tmpcode)\\n\\n \\n\\n ####\\n # Construct trial dynamics\\n rule_ind = np.arange(12) # rules are the first 12 indices of input vector\\n stim_ind = np.arange(12,28) # stimuli are the last 16 indices of input vector\\n input_size = len(rule_ind) + len(stim_ind)\\n n_tp_total = 36 # total length of miniblock -- cpro task details\\n input_matrix = np.zeros((input_size,n_tp_total,nMiniblocks))\\n output_matrix = np.zeros((4,n_tp_total,nMiniblocks))\\n trial = 0\\n for block in range(nMiniblocks):\\n # Define trial dynamics\\n n_tp_encoding = 5\\n n_tp_encodingdelay = np.random.randint(2,9) # encoding delay is jittered from 2 - 8 trs\\n n_tp_trial = 3\\n n_tp_probedelay = 2\\n n_tp_trial_end = n_tp_total - n_tp_encoding - n_tp_encodingdelay - n_tp_trial*3 - n_tp_probedelay*2 # full miniblock is 36 trs\\n\\n\\n rand_stim_ind = np.random.choice(stimIndices,n_trials_per_block,replace=False)\\n stimuliSet2 = stimuliSet.iloc[rand_stim_ind].copy(deep=True)\\n stimuliSet2 = stimuliSet2.reset_index(drop=True)\\n \\n # Create trial array\\n networkInputCode2 = []\\n networkOutputCode2 = []\\n tp = 0\\n # Encoding\\n for i in range(n_tp_encoding):\\n input_matrix[rule_ind,tp,block] = taskRuleSet.Code[block] \\n tp += 1\\n\\n # Encoding delay\\n tp += n_tp_encodingdelay\\n\\n # Trials\\n for trial in range(n_trials_per_block):\\n # First solve trial\\n tmpresp, out_code = task.solveInputs(taskRuleSet.iloc[block], stimuliSet2.iloc[trial])\\n\\n # probe\\n for i in range(n_tp_trial):\\n input_matrix[stim_ind,tp,block] = stimuliSet2.Code[trial]\\n # Commented out - response period will be limited to ITI following stimulus\\n #output_matrix[:,tp,block] = out_code\\n tp += 1\\n\\n # probe delay\\n for i in range(n_tp_probedelay):\\n output_matrix[:,tp,block] = out_code\\n tp += 1\\n \\n if shuffle:\\n ind = np.arange(input_matrix.shape[2],dtype=int)\\n np.random.shuffle(ind)\\n input_matrix = input_matrix[:,:,ind]\\n output_matrix = output_matrix[:,:,ind]\\n \\n return input_matrix, output_matrix\",\n \"def run(config, software, im_fns, check=True):\\n log = logging.getLogger(__name__)\\n if check:\\n check_requirements(config, software)\\n reference_im_fn = config.reference_im_fn\\n selection = config.selection\\n result_dir = config.result_dir\\n ants_params = config.ants_params\\n num_of_iterations_per_level = config.num_of_iterations_per_level\\n num_of_levels = config.num_of_levels # multiscale bluring (coarse-to-fine)\\n\\n s = time.time()\\n\\n pyLAR.affineRegistrationStep(software.EXE_BRAINSFit, im_fns, result_dir, selection, reference_im_fn)\\n #cnormalizeIntensityStep()\\n #histogramMatchingStep()\\n\\n num_of_data = len(selection)\\n iterCount = 0\\n for level in range(0, num_of_levels):\\n for iterCount in range(1, num_of_iterations_per_level+1):\\n log.info('Level: ' + str(level))\\n log.info('Iteration ' + str(iterCount))\\n _runIteration(level, iterCount, ants_params, result_dir, selection, software)\\n gc.collect() # garbage collection\\n # We need to check if num_of_iterations_per_level is set to 0, which leads\\n # to computing an average on the affine registration.\\n if level != num_of_levels - 1:\\n log.warning('No need for multiple levels! TO BE REMOVED!')\\n for i in range(num_of_data):\\n current_file_name = 'L' + str(level) + '_Iter' + str(iterCount) + '_' + str(i) + '.nrrd'\\n current_file_path = os.path.join(result_dir, current_file_name)\\n nextLevelInitIm = os.path.join(result_dir, 'L'+str(level+1)+'_Iter0_' + str(i) + '.nrrd')\\n shutil.copyfile(current_file_path, nextLevelInitIm)\\n # if num_of_levels > 1:\\n # print 'WARNING: No need for multiple levels! TO BE REMOVED!'\\n # for i in range(num_of_data):\\n # next_prefix = 'L' + str(level+1) + '_Iter0_'\\n # next_path = os.path.join(result_dir, next_prefix)\\n # newLevelInitIm = next_path + str(i) + '.nrrd'\\n current_prefix = 'L' + str(num_of_levels-1) + '_Iter' + str(num_of_iterations_per_level)\\n current_path = os.path.join(result_dir, current_prefix)\\n atlasIm = current_path + '_atlas.nrrd'\\n listOfImages = []\\n num_of_data = len(selection)\\n for i in range(num_of_data):\\n lrIm = current_path + '_' + str(i) + '.nrrd'\\n listOfImages.append(lrIm)\\n pyLAR.AverageImages(software.EXE_AverageImages, listOfImages, atlasIm)\\n logging.debug(\\\"Saves list outputs:%s\\\"%(os.path.join(result_dir,'list_outputs.txt')))\\n pyLAR.writeTxtFromList(os.path.join(result_dir,'list_outputs.txt'),[atlasIm])\\n try:\\n import matplotlib.pyplot as plt\\n import SimpleITK as sitk\\n import numpy as np\\n im = sitk.ReadImage(atlasIm)\\n im_array = sitk.GetArrayFromImage(im)\\n z_dim, x_dim, y_dim = im_array.shape\\n plt.figure()\\n plt.imshow(np.flipud(im_array[z_dim/2, :]), plt.cm.gray)\\n plt.title(current_prefix + ' atlas')\\n plt.savefig(current_path + '.png')\\n except ImportError:\\n pass\\n\\n e = time.time()\\n l = e - s\\n log.info('Total running time: %f mins' % (l/60.0))\",\n \"def main(parameters):\\n metadata = get_metadata(parameters)\\n # pprint(metadata)\\n image_api = NswSatelliteImages(parameters, metadata)\\n print('Zoom level:', image_api.zoom_level,\\n 'Resolution:', image_api.resolution,\\n 'Scale:', image_api.scale)\\n image_api.download_tile(xtile=39000, ytile=60000)\",\n \"def main():\\n \\n # for inserting other images, add tem to /input folder and list them here\\n images = (\\n 'image-0',\\n 'image-1',\\n 'image-2'\\n )\\n\\n for image_name in images:\\n print(image_name, \\\"image:\\\")\\n\\n image = open_image(image_name)\\n display_image(image, \\\"Original input \\\" + image_name)\\n\\n grayscale_v = transform_colors(image)\\n display_image(grayscale_v[:,:,0], \\\"Grayscale \\\" + image_name)\\n save_image(image_name + \\\"-grayscale\\\", grayscale_v[:,:,0])\\n\\n contours_v, contours = get_contours(grayscale_v)\\n display_image(contours_v, \\\"Contours \\\" + image_name)\\n save_image(image_name + \\\"-contours\\\", contours_v)\\n\\n labeled_img, areas = get_measures(image, contours[1:])\\n display_image(labeled_img, \\\"Labeled \\\" + image_name)\\n save_image(image_name + \\\"-labeled\\\", labeled_img)\\n\\n areas_histogram(areas, image_name)\",\n \"def generate_base_tiles(self):\\n\\n gdal.SetConfigOption(\\\"GDAL_PAM_ENABLED\\\", \\\"NO\\\")\\n\\n print \\\"Generating Base Tiles:\\\"\\n if self.options.verbose:\\n #mx, my = self.out_gt[0], self.out_gt[3] # OriginX, OriginY\\n #px, py = self.mercator.MetersToPixels( mx, my, self.tmaxz)\\n #print \\\"Pixel coordinates:\\\", px, py, (mx, my)\\n print\\n print \\\"Tiles generated from the max zoom level:\\\"\\n print \\\"----------------------------------------\\\"\\n print\\n\\n\\n # Set the bounds\\n tminx, tminy, tmaxx, tmaxy = self.tminmax[self.tmaxz]\\n querysize = self.querysize\\n\\n # Just the center tile\\n #tminx = tminx+ (tmaxx - tminx)/2\\n #tminy = tminy+ (tmaxy - tminy)/2\\n #tmaxx = tminx\\n #tmaxy = tminy\\n\\n #print tminx, tminy, tmaxx, tmaxy\\n tcount = (1+abs(tmaxx-tminx)) * (1+abs(tmaxy-tminy))\\n #print tcount\\n ti = 0\\n i_y_column_count=((tmaxy-tminy)+1)\\n ds = self.out_ds\\n tz = self.tmaxz\\n if self.options.verbose:\\n # tx in range(tminx, tmaxx+1) tminx[ 281596 ] tmaxx[ 281744 ] ; ((tmaxx-tmaxy)+1) x_tiles[ 23393 ]\\n print \\\"\\\\ttz=[\\\",tz,\\\"] : tx in range(tminx, tmaxx+1) tminx[\\\",tminx,\\\"] tmaxx[\\\",tmaxx,\\\"] ; ((tmaxx-tmaxy)+1) x_tiles[\\\",tcount,\\\"]\\\"\\n # ty_tms in range(tmaxy, tminy-1, -1) tmaxy[ 352409 ] tminy[ 352253 ] ; ((tmaxy-tminy)) y_tiles[ 157 ] 352409-(352253-1)\\n print \\\"\\\\ttz=[\\\",tz,\\\"] : ty_tms in range(tmaxy, tminy-1, -1) tmaxy[\\\",tmaxy,\\\"] tminy[\\\",tminy,\\\"] ; ((tmaxy-tminy+1)) y_tiles[\\\",i_y_column_count,\\\"]\\\"\\n if self.options.resume:\\n i_count = self.tile_exists(0, 0, tz,2)\\n if i_count == tcount:\\n if self.options.verbose:\\n print \\\"\\\\tTile generation skipped because of --resume ; x/y-tiles of z[\\\",tz,\\\"] y_tiles[\\\",tcount,\\\"]\\\"\\n return\\n for tx in range(tminx, tmaxx+1):\\n tmaxy_work=tmaxy\\n if self.options.resume:\\n i_count = self.tile_exists(tx, 0, tz,3)\\n if i_count == i_y_column_count:\\n if self.options.verbose:\\n print \\\"\\\\tTile generation skipped because of --resume ; z =\\\",tz,\\\" ; y-tiles of x[\\\",tx,\\\"] y_tiles[\\\",i_y_column_count,\\\"]\\\"\\n break\\n else:\\n if i_count > 0:\\n # this assums the rows are compleate, which may NOT be true\\n tmaxy_work-=i_count\\n if self.options.verbose:\\n print \\\"\\\\tTile generation skipped to tmaxy[\\\",tmaxy_work,\\\"] because of --resume ; z =\\\",tz,\\\" ; y-tiles of x[\\\",tx,\\\"] y_tiles[\\\",i_y_column_count,\\\"]\\\"\\n for ty_tms in range(tmaxy_work, tminy-1, -1): #range(tminy, tmaxy+1):\\n ty_osm=self.flip_y(tz,ty_tms)\\n ty=ty_tms\\n if self.options.tms_osm:\\n ty=ty_osm\\n if self.stopped:\\n if self.options.mbtiles:\\n if self.mbtiles_db:\\n self.mbtiles_db.close_db()\\n break\\n ti += 1\\n\\n if self.options.resume:\\n exists = self.tile_exists(tx, ty, tz,0)\\n if exists and self.options.verbose:\\n print \\\"\\\\tTile generation skipped because of --resume ; z =\\\",tz,\\\" ; x =\\\",tx,\\\" ; y_tms =\\\",ty_tms, \\\"; y_osm =\\\",ty_osm\\n else:\\n exists = False\\n\\n if not exists:\\n if self.options.verbose:\\n print ti, '/', tcount, self.get_verbose_tile_name(tx, ty, tz)\\n # Don't scale up by nearest neighbour, better change the querysize\\n # to the native resolution (and return smaller query tile) for scaling\\n if self.options.profile in ('mercator','geodetic'):\\n if self.options.profile == 'mercator':\\n # Tile bounds in EPSG:900913\\n b = self.mercator.TileBounds(tx, ty_tms, tz)\\n elif self.options.profile == 'geodetic':\\n b = self.geodetic.TileBounds(tx, ty_tms, tz)\\n\\n rb, wb = self.geo_query( ds, b[0], b[3], b[2], b[1])\\n nativesize = wb[0]+wb[2] # Pixel size in the raster covering query geo extent\\n if self.options.verbose:\\n print \\\"\\\\tNative Extent (querysize\\\",nativesize,\\\"): \\\", rb, wb\\n\\n querysize = self.querysize\\n # Tile bounds in raster coordinates for ReadRaster query\\n rb, wb = self.geo_query( ds, b[0], b[3], b[2], b[1], querysize=querysize)\\n\\n rx, ry, rxsize, rysize = rb\\n wx, wy, wxsize, wysize = wb\\n else: # 'raster' or 'gearth' or 'garmin' profile:\\n tsize = int(self.tsize[tz]) # tilesize in raster coordinates for actual zoom\\n xsize = self.out_ds.RasterXSize # size of the raster in pixels\\n ysize = self.out_ds.RasterYSize\\n if tz >= self.nativezoom:\\n querysize = self.tilesize # int(2**(self.nativezoom-tz) * self.tilesize)\\n\\n rx = (tx) * tsize\\n rxsize = 0\\n if tx == tmaxx:\\n rxsize = xsize % tsize\\n if rxsize == 0:\\n rxsize = tsize\\n\\n rysize = 0\\n if ty_tms == tmaxy:\\n rysize = ysize % tsize\\n if rysize == 0:\\n rysize = tsize\\n ry = ysize - (ty_tms * tsize) - rysize\\n\\n wx, wy = 0, 0\\n\\n wxsize, wysize = int(rxsize/float(tsize) * querysize), int(rysize/float(tsize) * querysize)\\n if wysize != querysize:\\n wy = querysize - wysize\\n xyzzy = Xyzzy(querysize, rx, ry, rxsize, rysize, wx, wy, wxsize, wysize)\\n try:\\n if self.options.verbose:\\n print ti,'/',tcount,' total ; z =',tz,' ; x =',tx,' ; y_tms =',ty_tms,' ; y_osm =',ty_osm\\n print \\\"\\\\tReadRaster Extent: \\\", (rx, ry, rxsize, rysize), (wx, wy, wxsize, wysize)\\n self.write_base_tile(tx, ty, tz, xyzzy)\\n except ImageOutputException, e:\\n self.error(\\\"'%d/%d/%d': %s\\\" % (tz, tx, ty, e.message))\\n\\n if not self.options.verbose or self.is_subprocess:\\n self.progressbar( ti / float(tcount) )\\n if self.options.mbtiles:\\n if self.mbtiles_db:\\n self.mbtiles_db.close_db()\\n self.mbtiles_db=None\",\n \"def ttd_image(img, tiq_palette, mapping, verbose=False):\\n img_out = Image.new('P', img.size, color=None)\\n pil_palette = [v for t in tiq_palette.palette for v in t]\\n img_out.putpalette(pil_palette)\\n pixels_in = img.load()\\n pixels_out = img_out.load()\\n for y in range(img.size[1]):\\n for x in range (img.size[0]):\\n if verbose and pixels_in[x, y] != mapping[pixels_in[x, y]]:\\n print(\\\"x:{}, y:{}, {} -> {}\\\".format(x, y, pixels_in[x, y],\\n mapping[pixels_in[x, y]]))\\n pixels_out[x, y] = tiq_palette.rgb_to_i[mapping[pixels_in[x, y]]]\\n return img_out\",\n \"def take(self, n, wordnetid=None):\\n subjectid = np.random.choice(self.subjects(), n) if wordnetid is None else [wordnetid] * n\\n takelist = []\\n for s in subjectid:\\n d = os.path.join(self.datadir, s)\\n f = np.random.choice(imlist(d),1)[0]\\n im = ImageDetection(filename=f).category(filebase(d))\\n takelist.append(im)\\n return takelist\",\n \"def test_image_task(self):\\n args = BASE_ARGS.copy()\\n args.update(IMAGE_ARGS)\\n\\n valid, test = testing_utils.train_model(args)\\n self.assertLessEqual(\\n valid['ppl'], 8.6, 'failed to train image_seq2seq on image task'\\n )\",\n \"def NAME():\\n\\n # Location of data\\n base_dir = \\\"(Location)\\\" #Location of align tif --> Should be the location of the experiment's align tiff folder, ex: \\\"C/desktop/work/image_processing/YYYYMMDD/align_tiffs\\\"\\n resolution = {'res_xy_nm': 100, 'res_z_nm': 70} #Resolution of a pixel (do not alter)\\n thresh = 0.9 #What qualifies for final probability map (do not alter)\\n number_of_datasets = 20 #Number of wells in the experiemnts, \\\"20\\\" is an example where there are 16 samples and 4 controls\\n\\n #Rb Antibody\\n conjugate_fn_str = 'GAD2' #String segment to search in a filename\\n #conjugate_fn_str should be the term used in the name of the control align tiff for a well (usually \\\"PSD\\\", \\\"GAD2\\\", or \\\"SYNAPSIN\\\")\\n target_fn_str = 'L106'\\n #Ms Antibody project name, no parent or subclone number needed\\n #target_fn_str should be the project number, for instance if this was testing L109 samples, this would be \\\"L109\\\"\\n #Takes base directory string and gives you an array of all the files within\\n filenames = aa.getListOfFolders(base_dir) #Do not change\\n conjugate_filenames = [] #Do not change\\n target_filenames = [] #Do not change\\n query_list = [] #Do not change\\n folder_names = [] #Do not change\\n\\n for n in range(1, 17):\\n #Use if dataset missing\\n #This is where you put in the rangee of wells used as your test samples\\n #Since we have 16 samples that are test samples for L106, the range is equal to 1 through n+1, or 1 through 17\\n #If your test samples do not begin at well 1, then adjust the beginning of the range accordingly (3 through 17 if the first test sample is in well 3) \\n #continue\\n\\n print('Well: ', str(n)) #Do not change\\n folder_names.append('Test-' + str(n)) # Collate 'dataset' names for excel sheet #Do not change\\n conjugate_str = str(n) + '-' + conjugate_fn_str #creates filename to search for #Creates n-conjugatename #Do not change\\n target_str = str(n) + '-' + target_fn_str #Do not change\\n\\n # Search for file associated with the specific dataset number\\n indices = [i for i, s in enumerate(filenames) if conjugate_str == s[0:len(conjugate_str)]] #Do not change\\n conjugate_name = filenames[indices[0]] #Do not change\\n print(conjugate_name) #Do not change\\n indices = [i for i, s in enumerate(filenames) if target_str == s[0:len(target_str)]] #Do not change\\n target_name = filenames[indices[0]] #Do not change\\n print(target_name) #Do not change\\n \\n conjugate_filenames.append(conjugate_name) #Do not change\\n target_filenames.append(target_name) #Do not change\\n\\n # Create query\\n #\\n query = {'preIF': [conjugate_name], 'preIF_z': [2],\\n 'postIF': [target_name], 'postIF_z': [1],\\n 'punctumSize': 2}\\n #preIF = items that are presynaptic targets go here, because GAD2, our conjugate, is presynaptic I put the conjugate_name in this box\\n #preIF_z = how many tiffs a puncta must be in to be registered, conjugate sample number is 2 so 2 goes in this box\\n #postIF = items that are postsynaptic targets go here, L106 is postsynaptic so I put target_name here\\n #postIF_z = how many tiffs a puncta must be in to be registered, target sample number is 1 (for now unless changed later) \\n #punctumSize = size of punctum the algorithm is looking for, do not change unless directed to\\n\\n \\\"\\\"\\\"Example of a presynaptic target and presynaptic conjugate\\n query = {'preIF': [target_name,conjugate_name], 'preIF_z': [1,2],\\n 'postIF': [], 'postIF_z': [],\\n 'punctumSize': 2}\\\"\\\"\\\"\\n\\n \\\"\\\"\\\"Example of a postsynaptic target and presynaptic conjugate\\n query = {'preIF': [conjugate_name], 'preIF_z': [2],\\n 'postIF': [target_name], 'postIF_z': [1],\\n 'punctumSize': 2}\\\"\\\"\\\"\\n\\n \\\"\\\"\\\"Example of a postsynaptic target and postsynaptic conjugate\\n query = {'preIF': [], 'preIF_z': [],\\n 'postIF': [target_name,conjugate_name], 'postIF_z': [1,2],\\n 'punctumSize': 2}\\\"\\\"\\\"\\n\\n \\\"\\\"\\\"Example of a presynaptic target and postsynaptic conjugate\\n query = {'preIF': [target_name], 'preIF_z': [1],\\n 'postIF': [conjugate_name], 'postIF_z': [2],\\n 'punctumSize': 2}\\\"\\\"\\\"\\n\\n\\n query_list.append(query)\\n\\n\\n #The following n samples are controls - you can add as many of these as you want by copying the block of code and pasting it after the last one\\n #The notes in the following block of code apply to all of the controls\\n n = 17 #well number of control sample\\n folder_names.append('Control' + str(n)) # Collate 'dataset' names for excel sheet #Do not change\\n reference_fn_str = 'GAD2' #String segment to search in a filename #refernce_fn_str is the project number/name of RB control\\n target_fn_str = 'L106' #target_fn_str is the project number of the Ms control you are using\\n conjugate_name, target_name = aa.findFilenames(reference_fn_str, target_fn_str, filenames, n) #Do not alter\\n conjugate_filenames.append(conjugate_name) #Do not alter\\n target_filenames.append(target_name) #Do not alter\\n query = {'preIF': [conjugate_name], 'preIF_z': [2], 'postIF': [target_name], 'postIF_z': [1], 'punctumSize': 2} #Se the examples and explanations above about \\\"query\\\"\\n query_list.append(query) #Do not change\\n\\n n = 18\\n folder_names.append('Control' + str(n)) # Collate 'dataset' names for excel sheet\\n reference_fn_str = 'GAD2' #String segment to search in a filename\\n target_fn_str = 'SP2'\\n conjugate_name, target_name = aa.findFilenames(reference_fn_str, target_fn_str, filenames, n)\\n conjugate_filenames.append(conjugate_name)\\n target_filenames.append(target_name)\\n query = {'preIF': [target_name,conjugate_name], 'preIF_z': [1,2], 'postIF': [], 'postIF_z': [], 'punctumSize': 2}\\n query_list.append(query)\\n\\n n = 19\\n folder_names.append('Control' + str(n)) # Collate 'dataset' names for excel sheet\\n reference_fn_str = 'NP-RB' #String segment to search in a filename\\n target_fn_str = 'NP-MS'\\n conjugate_name, target_name = aa.findFilenames(reference_fn_str, target_fn_str, filenames, n)\\n conjugate_filenames.append(conjugate_name)\\n target_filenames.append(target_name)\\n query = {'preIF': [], 'preIF_z': [], 'postIF': [target_name,conjugate_name], 'postIF_z': [1,2], 'punctumSize': 2}\\n query_list.append(query)\\n\\n n = 20\\n folder_names.append('Control' + str(n)) # Collate 'dataset' names for excel sheet\\n reference_fn_str = 'NPNS-RB' #String segment to search in a filename\\n target_fn_str = 'NPNS-MS'\\n conjugate_name, target_name = aa.findFilenames(reference_fn_str, target_fn_str, filenames, n)\\n conjugate_filenames.append(conjugate_name)\\n target_filenames.append(target_name)\\n query = {'preIF': [], 'preIF_z': [], 'postIF': [target_name,conjugate_name], 'postIF_z': [1,2], 'punctumSize': 2}\\n query_list.append(query)\\n\\n\\n \\n measure_list = aa.calculate_measure_lists(query_list, None, base_dir,\\n thresh, resolution, target_filenames) # Run all the queries\\n\\n df = aa.create_df(measure_list, folder_names, target_filenames, conjugate_filenames) #Do not change\\n print(df) #Do not change\\n\\n return df #Do not change\",\n \"def create_test_set(self):\\n test_files = os.listdir(self.image_folder_path)\\n test_files = sorted_alphanumeric(test_files)\\n delete_files(self.root_name, \\\"/VOC2021/ImageSets/Main\\\")\\n write_txt(\\\"test.txt\\\", self.txt_path, test_files)\",\n \"def gen_simple_test():\\n count = 1\\n mdict = {\\n 'operating_frequency': 3e8,\\n 'sample_rate': 8e3,\\n 'signal': [1] * 5,\\n 'origin_pos': [1000, 0, 0],\\n 'dest_pos': [300, 200, 50],\\n 'origin_vel': [0] * 3,\\n 'dest_vel': [0] * 3,\\n }\\n io.savemat('{}{}_input'.format(tests_path, count), mdict)\",\n \"def sample_replay_goal(self, obs):\\n assert self._config.gc_input != 'state'\\n random_batch = next(self._dataset)\\n random_batch = self._wm.preprocess(random_batch)\\n \\n images = random_batch['image']\\n states = random_batch['state']\\n if self._config.labelled_env_multiplexing:\\n assert obs['env_idx'].shape[0] == 1\\n env_ids = random_batch['env_idx'][:, 0]\\n if tf.reduce_any(env_ids == obs['env_idx']):\\n ids = np.nonzero(env_ids == obs['env_idx'])[0]\\n images = tf.gather(images, ids)\\n states = tf.gather(states, ids)\\n \\n random_goals = tf.reshape(images, (-1,) + tuple(images.shape[2:]))\\n random_goal_states = tf.reshape(states, (-1,) + tuple(states.shape[2:]))\\n # random_goals = tf.random.shuffle(random_goals)\\n return random_goals[:obs['image_goal'].shape[0]], random_goal_states[:obs['image_goal'].shape[0]]\",\n \"def get_sample(self, index: int) -> Mapping[str, io.BytesIO]:\\n del index\\n if self._generated_image:\\n return dict(images=self._generated_image)\\n\\n image_shape = (self._image_width, self._image_height, 3)\\n array = np.uint8(np.random.rand(*image_shape) * 255)\\n pil_image = Image.fromarray(array)\\n image_io = io.BytesIO()\\n pil_image.save(image_io, format=self._image_format)\\n self._generated_image = image_io.getvalue()\\n\\n return dict(images=self._generated_image)\",\n \"def generate(simulator, p, starts, goals, environment, r):\\n num_gen_humans = min(len(starts), len(goals))\\n print(\\\"Generating auto humans:\\\", num_gen_humans)\\n from agents.humans.human_configs import HumanConfigs\\n for i in range(num_gen_humans):\\n start_config = generate_config_from_pos_3(starts[i])\\n goal_config = generate_config_from_pos_3(goals[i])\\n start_goal_configs = HumanConfigs(start_config, goal_config)\\n human_i_name = \\\"auto_%04d\\\" % i\\n # Generates a random human from the environment\\n new_human_i = Human.generate_human_with_configs(\\n start_goal_configs,\\n generate_appearance=p.render_3D,\\n name=human_i_name\\n )\\n # update renderer and get human traversible if it exists\\n if p.render_3D:\\n r.add_human(new_human_i)\\n environment[\\\"human_traversible\\\"] = \\\\\\n np.array(r.get_human_traversible())\\n\\n # Input human fields into simulator\\n simulator.add_agent(new_human_i)\",\n \"def generate_targets(self, data):\\n\\n assert isinstance(data, dict)\\n\\n image = data['image']\\n polygons = data['polys']\\n ignore_tags = data['ignore_tags']\\n h, w, _ = image.shape\\n\\n polygon_masks = []\\n polygon_masks_ignore = []\\n for tag, polygon in zip(ignore_tags, polygons):\\n if tag is True:\\n polygon_masks_ignore.append(polygon)\\n else:\\n polygon_masks.append(polygon)\\n\\n gt_text_mask = self.generate_text_region_mask((h, w), polygon_masks)\\n gt_mask = self.generate_effective_mask((h, w), polygon_masks_ignore)\\n (center_lines, gt_center_region_mask, gt_top_height_map,\\n gt_bot_height_map, gt_sin_map,\\n gt_cos_map) = self.generate_center_mask_attrib_maps((h, w),\\n polygon_masks)\\n\\n gt_comp_attribs = self.generate_comp_attribs(\\n center_lines, gt_text_mask, gt_center_region_mask,\\n gt_top_height_map, gt_bot_height_map, gt_sin_map, gt_cos_map)\\n\\n mapping = {\\n 'gt_text_mask': gt_text_mask,\\n 'gt_center_region_mask': gt_center_region_mask,\\n 'gt_mask': gt_mask,\\n 'gt_top_height_map': gt_top_height_map,\\n 'gt_bot_height_map': gt_bot_height_map,\\n 'gt_sin_map': gt_sin_map,\\n 'gt_cos_map': gt_cos_map\\n }\\n\\n data.update(mapping)\\n data['gt_comp_attribs'] = gt_comp_attribs\\n return data\",\n \"def image_cli(\\n caps_directory: str,\\n modality: str,\\n subjects_sessions_tsv: Optional[str] = None,\\n use_uncropped_image: bool = False,\\n acq_label: Optional[str] = None,\\n suvr_reference_region: Optional[str] = None,\\n custom_suffix: str = \\\"\\\",\\n):\\n parameters = get_parameters_dict(\\n modality,\\n \\\"image\\\",\\n False,\\n use_uncropped_image,\\n custom_suffix,\\n acq_label,\\n suvr_reference_region,\\n )\\n DeepLearningPrepareData(\\n caps_directory=caps_directory,\\n tsv_file=subjects_sessions_tsv,\\n parameters=parameters,\\n )\",\n \"def build_tiles(img,tilefile,tilesize,options=[]):\\n\\tlevels=ceil(log(max(img.get_xsize(),img.get_ysize())/tilesize)/log(2.0))\\n\\t\\n\\ttf=file(tilefile,\\\"w\\\")\\n\\t\\n\\ttile_dict={}\\n\\tpos=0\\n\\timg2=img.copy()\\n\\txs,ys=img2.get_xsize(),img2.get_ysize()\\n\\tfor l in range(int(levels)):\\n\\t\\trmin=img2.get_attr(\\\"mean\\\")-img2.get_attr(\\\"sigma\\\")*3.0\\n\\t\\trmax=img2.get_attr(\\\"mean\\\")+img2.get_attr(\\\"sigma\\\")*3.0\\n\\t\\tfor x in range(0,img2.get_xsize(),tilesize):\\n\\t\\t\\tfor y in range(0,img2.get_ysize(),tilesize):\\n\\t\\t\\t\\ti=img2.get_clip(Region(x,y,tilesize,tilesize))\\n\\t\\t\\t\\ti.set_attr(\\\"render_min\\\",rmin)\\n\\t\\t\\t\\ti.set_attr(\\\"render_max\\\",rmax)\\n\\t\\t\\t\\ti.set_attr(\\\"jpeg_quality\\\",70)\\n\\t\\t\\t\\tfsp=\\\"tmpimg.%d.%03d.%03d.jpg\\\"%(l,x/tilesize,y/tilesize)\\n\\t\\t\\t\\ti.write_image(fsp)\\n\\t\\t\\t\\tsz=os.stat(fsp).st_size\\n\\t\\t\\t\\ttile_dict[(l,x/tilesize,y/tilesize)]=(pos,sz)\\n\\t\\t\\t\\tpos+=sz\\n\\t\\timg2.process_inplace(\\\"math.meanshrink\\\",{\\\"n\\\":2})\\n\\t\\n\\t# This will produce 2 power spectrum images in the tile file\\n\\t# with scale factors -1 and -2\\n\\tif \\\"pspec\\\" in options :\\n\\t\\tnx,ny=img.get_xsize()/512,img.get_ysize()/512\\n\\t\\ta=EMData()\\n\\t\\ta.set_size(512,512)\\n\\t\\tif (ny>2 and nx>2) :\\n\\t\\t\\tfor y in range(1,ny-1):\\n\\t\\t\\t\\tfor x in range(1,nx-1):\\n\\t\\t\\t\\t\\tc=img.get_clip(Region(x*512,y*512,512,512))\\n\\t\\t\\t\\t\\tc.process_inplace(\\\"normalize\\\")\\n\\t\\t\\t\\t\\tc.process_inplace(\\\"math.realtofft\\\")\\n\\t\\t\\t\\t\\tc.process_inplace(\\\"math.squared\\\")\\n\\t\\t\\t\\t\\ta+=c\\n\\t\\t\\ta.set_value_at(256,256,0,.01)\\n\\t\\t\\ta-=a.get_attr(\\\"minimum\\\")-a.get_attr(\\\"sigma\\\")*.01\\n\\t\\t\\ta.process_inplace(\\\"math.log\\\")\\n\\t\\t\\ta-=a.get_attr(\\\"minimum\\\")\\n\\t\\t\\ta.set_attr(\\\"render_min\\\",a.get_attr(\\\"minimum\\\")-a.get_attr(\\\"sigma\\\")*.1)\\n\\t\\t\\ta.set_attr(\\\"render_max\\\",a.get_attr(\\\"mean\\\")+a.get_attr(\\\"sigma\\\")*4.0)\\n\\t\\t\\ta.set_attr(\\\"jepg_quality\\\",80)\\n\\t\\t\\ta.write_image(\\\"/tmp/tmpimg.mrc\\\")\\n\\t\\t\\tfsp=\\\"tmpimg.jpg\\\"\\n\\t\\t\\ta.write_image(fsp)\\n\\t\\t\\tsz=os.stat(fsp).st_size\\n\\t\\t\\ttile_dict[(-1,0,0)]=(pos,sz)\\n\\t\\t\\tpos+=sz\\n\\t\\n#\\t\\ttry:\\n\\t\\t\\timport matplotlib\\n\\t\\t\\tmatplotlib.use('Agg')\\n\\t\\t\\timport pylab\\n\\t\\t\\tmanager = pylab.get_current_fig_manager()\\n\\t\\t\\tapix=options[\\\"pspec\\\"]\\n\\t\\t\\tdx=1.0/(2.0*apix*256.0)\\n\\t\\t\\tx=pylab.arange(dx,dx*255.9,dx)\\n\\t\\t\\ty=a.calc_radial_dist(255,1,1,0)\\t# radial power spectrum (log)\\n\\t\\t\\tpylab.figure(figsize=(8,6),dpi=96)\\n\\t\\t\\tpylab.axes([.08,.08,.9,.9], axisbg='w')\\n\\t\\t\\tpylab.plot(x,y)\\n\\t\\t\\tpylab.axis([0,dx*256,min(y),max(y)])\\n\\t\\t\\tpylab.xlabel(\\\"Spatial Freq. (1/A)\\\")\\n\\t\\t\\tpylab.ylabel(\\\"Log Intensity (10^x)\\\")\\n#\\t\\t\\tprint y\\n\\t\\t\\t\\n\\t\\t\\tfsp=\\\"tmpimg2.png\\\"\\n\\t\\t\\tpylab.savefig(fsp,dpi=96)\\n\\t\\t\\tsz=os.stat(fsp).st_size\\n\\t\\t\\ttile_dict[(-2,0,0)]=(pos,sz)\\n\\t\\t\\tpos+=sz\\n\\n#\\t\\texcept:\\n#\\t\\t\\tprint \\\"Unable to generate plot (need matplotlib)\\\"\\n\\t\\t\\t\\n\\t\\n\\tpickle.dump(tile_dict,tf)\\n\\t\\n\\tfor l in range(int(levels)):\\n\\t\\tfor x in range(0,xs,tilesize):\\n\\t\\t\\tfor y in range(0,ys,tilesize):\\n\\t\\t\\t\\tfsp=\\\"tmpimg.%d.%03d.%03d.jpg\\\"%(l,x/tilesize,y/tilesize)\\n\\t\\t\\t\\ta=file(fsp,\\\"r\\\")\\n\\t\\t\\t\\tb=a.read()\\n\\t\\t\\t\\ta.close()\\n\\t\\t\\t\\ttf.write(b)\\n\\t\\t\\t\\tos.remove(fsp)\\n\\t\\txs/=2\\n\\t\\tys/=2\\n\\t\\n\\tif \\\"pspec\\\" in options :\\n\\t\\tfor fsp in [\\\"tmpimg.jpg\\\",\\\"tmpimg2.png\\\"] :\\n\\t\\t\\ta=file(fsp,\\\"r\\\")\\n\\t\\t\\tb=a.read()\\n\\t\\t\\ta.close()\\n\\t\\t\\ttf.write(b)\\n#\\t\\t\\tos.remove(fsp)\\n\\t\\n\\ttf.close()\",\n \"def run_automatic_tester():\\n number_of_target_maps = len(os.listdir(TargetDetectionTesterSettings.TARGET_DETECTION_REPORT_JSON_FILE_SAVE_PATH))\\n overall_true_positive_count = 0\\n overall_false_positive_count = 0\\n overall_target_count = 0\\n\\n for index_0 in range(number_of_target_maps):\\n\\n answer_sheet = json.load(open(os.path.join(TargetDetectionTesterSettings.TARGET_MAP_ANSWER_SHEET_PATH, str(index_0 + 1) + \\\".json\\\")))\\n answer_list = []\\n\\n for index_1 in range(len(answer_sheet[\\\"targets\\\"])):\\n answer_list.append((answer_sheet[\\\"targets\\\"][index_1][\\\"target_center_coordinates\\\"][0], answer_sheet[\\\"targets\\\"][index_1][\\\"target_center_coordinates\\\"][1]))\\n overall_target_count += len(answer_list)\\n\\n target_detection_result = json.load(open(os.path.join(TargetDetectionTesterSettings.TARGET_DETECTION_REPORT_JSON_FILE_SAVE_PATH, str(index_0 + 1) + \\\".json\\\")))\\n result_list = []\\n\\n for index_2 in range(len(target_detection_result[\\\"image_processing_results\\\"])):\\n result_list.append((target_detection_result[\\\"image_processing_results\\\"][index_2][\\\"target_location\\\"][0] + (target_detection_result[\\\"image_processing_results\\\"][index_2][\\\"target_location\\\"][2] / 2), target_detection_result[\\\"image_processing_results\\\"][index_2][\\\"target_location\\\"][1] + (target_detection_result[\\\"image_processing_results\\\"][index_2][\\\"target_location\\\"][3] / 2)))\\n\\n current_true_positive_count = 0\\n current_false_positive_count = 0\\n banned_index_list = []\\n\\n for index_3 in range(len(answer_list)):\\n true_positive_found = False\\n\\n for index_4 in range(len(result_list)):\\n is_index_4_banned = False\\n\\n for index_5 in range(len(banned_index_list)):\\n if (index_4 == banned_index_list[index_5]):\\n is_index_4_banned = True\\n\\n if (is_index_4_banned == True):\\n continue\\n\\n correct_target_center_x = answer_list[index_3][0]\\n correct_target_center_y = answer_list[index_3][1]\\n\\n detected_target_center_x = result_list[index_4][0]\\n detected_target_center_y = result_list[index_4][1]\\n\\n if ((abs(correct_target_center_x - detected_target_center_x) <= 20) and (abs(correct_target_center_y - detected_target_center_y) <= 20)):\\n current_true_positive_count += 1\\n banned_index_list.append(index_4)\\n true_positive_found = True\\n continue\\n\\n current_false_positive_count = len(result_list) - current_true_positive_count\\n\\n overall_true_positive_count += current_true_positive_count\\n overall_false_positive_count += current_false_positive_count\\n\\n percentage = 100 * float(overall_true_positive_count) / (overall_target_count)\\n\\n TargetDetectionTesterLogger.log(\\\"--------------------------------------------------\\\")\\n TargetDetectionTesterLogger.log(\\\"Total True Positive Count: \\\" + str(overall_true_positive_count))\\n TargetDetectionTesterLogger.log(\\\"Total False Positive Count: \\\" + str(overall_false_positive_count))\\n TargetDetectionTesterLogger.log(\\\"Percentage of Successfully Detected Targets: \\\" + str(percentage) + \\\"%\\\")\\n TargetDetectionTesterLogger.log(\\\"--------------------------------------------------\\\")\",\n \"def generate_instance(num_facilities: int, num_towns: int, file_name: str) -> bool:\\r\\n\\r\\n facility_dictionary = [\\r\\n \\\"Perseus\\\",\\r\\n \\\"Andromeda\\\",\\r\\n \\\"Cassiopeia\\\",\\r\\n \\\"Cetus\\\",\\r\\n \\\"Cepheus\\\",\\r\\n \\\"Pegasus\\\",\\r\\n \\\"Auriga\\\",\\r\\n \\\"Hercules\\\",\\r\\n \\\"Sagitta\\\",\\r\\n \\\"Aquila\\\",\\r\\n \\\"Lyra\\\",\\r\\n \\\"Cygnus\\\",\\r\\n \\\"Hydra\\\",\\r\\n \\\"Crater\\\",\\r\\n \\\"Corvus\\\",\\r\\n \\\"Ophiuchus\\\",\\r\\n \\\"Serpens\\\",\\r\\n \\\"Centaurus\\\",\\r\\n \\\"Lupus\\\",\\r\\n \\\"Corona Australis\\\",\\r\\n \\\"Ara\\\",\\r\\n \\\"Orion\\\",\\r\\n \\\"Canis Major\\\",\\r\\n \\\"Canis Minor\\\",\\r\\n \\\"Lepus\\\",\\r\\n \\\"Monoceros\\\",\\r\\n \\\"Aries\\\",\\r\\n \\\"Taurus\\\",\\r\\n \\\"Gemini\\\",\\r\\n \\\"Cancer\\\",\\r\\n \\\"Leo\\\",\\r\\n \\\"Virgo\\\",\\r\\n \\\"Libra\\\",\\r\\n \\\"Scorpius\\\",\\r\\n \\\"Sagittarius\\\",\\r\\n \\\"Capricornus\\\",\\r\\n \\\"Aquarius\\\",\\r\\n \\\"Pisces\\\",\\r\\n \\\"Ursa Major\\\",\\r\\n \\\"Ursa Minor\\\",\\r\\n \\\"Draco\\\",\\r\\n \\\"Canes Venatici\\\",\\r\\n \\\"Boötes\\\",\\r\\n \\\"Corona Borealis\\\"\\r\\n ]\\r\\n towns_dictionary = [\\r\\n \\\"Rome\\\",\\r\\n \\\"Milan\\\",\\r\\n \\\"Naples\\\",\\r\\n \\\"Turin\\\",\\r\\n \\\"Florence\\\",\\r\\n \\\"Salerno\\\",\\r\\n \\\"Palermo\\\",\\r\\n \\\"Catania\\\",\\r\\n \\\"Genoa\\\",\\r\\n \\\"Bari\\\",\\r\\n \\\"Bologna\\\",\\r\\n \\\"Verona\\\",\\r\\n \\\"Pescara\\\",\\r\\n \\\"Cagliari\\\",\\r\\n \\\"Venice\\\",\\r\\n \\\"Messina\\\",\\r\\n \\\"Como\\\",\\r\\n \\\"Caserta\\\",\\r\\n \\\"Trieste\\\",\\r\\n \\\"Pisa\\\",\\r\\n \\\"Taranto\\\",\\r\\n \\\"Bergamo\\\",\\r\\n \\\"Reggio di Calabria\\\",\\r\\n \\\"Treviso\\\",\\r\\n \\\"Modena\\\",\\r\\n \\\"Parma\\\",\\r\\n \\\"Lecce\\\",\\r\\n \\\"Livorno\\\",\\r\\n \\\"Foggia\\\",\\r\\n \\\"Perugia\\\",\\r\\n \\\"Ravenna\\\",\\r\\n \\\"Ferrara\\\",\\r\\n \\\"Siracusa\\\",\\r\\n \\\"Sassari\\\",\\r\\n \\\"Udine\\\",\\r\\n \\\"Barletta\\\",\\r\\n \\\"Trento\\\",\\r\\n \\\"Brindisi\\\",\\r\\n \\\"Novara\\\",\\r\\n \\\"Ancona\\\",\\r\\n \\\"Soprabolzano\\\",\\r\\n \\\"Catanzaro\\\",\\r\\n \\\"Arezzo\\\",\\r\\n \\\"Marsala\\\",\\r\\n \\\"Asti\\\",\\r\\n \\\"Potenza\\\",\\r\\n \\\"Ragusa\\\",\\r\\n \\\"L’Aquila\\\",\\r\\n \\\"Benevento\\\",\\r\\n \\\"Civitavecchia\\\",\\r\\n \\\"Crotone\\\",\\r\\n \\\"Siena\\\",\\r\\n \\\"Campobasso\\\",\\r\\n \\\"Olbia\\\",\\r\\n \\\"Aosta\\\",\\r\\n \\\"Vibo Valentia\\\",\\r\\n \\\"Padova\\\",\\r\\n \\\"Savona\\\",\\r\\n \\\"Caltanissetta\\\",\\r\\n \\\"Vicenza\\\",\\r\\n \\\"Gorizia\\\",\\r\\n \\\"Rieti\\\",\\r\\n \\\"Grosseto\\\",\\r\\n \\\"Bolzano\\\",\\r\\n \\\"Massa\\\",\\r\\n \\\"Sanluri\\\",\\r\\n \\\"Latina\\\",\\r\\n \\\"Vercelli\\\",\\r\\n \\\"Belluno\\\",\\r\\n \\\"Cremona\\\",\\r\\n \\\"Oristano\\\",\\r\\n \\\"Mantova\\\",\\r\\n \\\"Prato\\\",\\r\\n \\\"Enna\\\",\\r\\n \\\"Lucca\\\",\\r\\n \\\"Viterbo\\\",\\r\\n \\\"Villacidro\\\",\\r\\n \\\"Trani\\\",\\r\\n \\\"Pavia\\\",\\r\\n \\\"Piacenza\\\",\\r\\n \\\"Monza\\\",\\r\\n \\\"Verbania\\\",\\r\\n \\\"Rimini\\\",\\r\\n \\\"Andria\\\",\\r\\n \\\"Fermo\\\",\\r\\n \\\"Nuoro\\\",\\r\\n \\\"Alessandria\\\",\\r\\n \\\"Matera\\\",\\r\\n \\\"Pistoia\\\",\\r\\n \\\"Reggio Emilia\\\",\\r\\n \\\"Frosinone\\\",\\r\\n \\\"Imperia\\\",\\r\\n \\\"Tortolì\\\",\\r\\n \\\"Iglesias\\\",\\r\\n \\\"Tempio Pausania\\\",\\r\\n \\\"Trapani\\\",\\r\\n \\\"Rovigo\\\",\\r\\n \\\"Teramo\\\",\\r\\n \\\"Sondrio\\\",\\r\\n \\\"Lanusei\\\",\\r\\n \\\"Biella\\\",\\r\\n \\\"Cosenza\\\",\\r\\n \\\"Cuneo\\\",\\r\\n \\\"Ascoli Piceno\\\",\\r\\n \\\"Avellino\\\",\\r\\n \\\"Chieti\\\",\\r\\n \\\"Terni\\\",\\r\\n \\\"Varese\\\",\\r\\n \\\"Forlì\\\",\\r\\n \\\"Lecco\\\",\\r\\n \\\"Carbonia\\\",\\r\\n \\\"Macerata\\\",\\r\\n \\\"La Spezia\\\",\\r\\n \\\"Pesaro\\\",\\r\\n \\\"Pordenone\\\",\\r\\n \\\"Lodi\\\",\\r\\n \\\"Brescia\\\",\\r\\n \\\"Agrigento\\\"\\r\\n ]\\r\\n\\r\\n if num_facilities > len(facility_dictionary) or num_towns > len(towns_dictionary):\\r\\n print(\\\"\\\\nToo many elements required:\\\")\\r\\n print(f\\\"\\\\tmax facilities: {len(facility_dictionary)}\\\")\\r\\n print(f\\\"\\\\tmax towns: {len(towns_dictionary)}\\\")\\r\\n return False\\r\\n\\r\\n if num_facilities < 1 or num_towns < 1:\\r\\n print(\\\"\\\\nFacility and towns elements must be more than 0\\\\n\\\")\\r\\n return False\\r\\n\\r\\n facilities = []\\r\\n towns = []\\r\\n hazards = []\\r\\n\\r\\n for i in range(num_facilities):\\r\\n facility = {\\r\\n \\\"facility_id\\\": i,\\r\\n \\\"name\\\": facility_dictionary[i],\\r\\n \\\"capacity\\\": math.floor(random.uniform(51, 300))\\r\\n }\\r\\n facilities.append(facility)\\r\\n\\r\\n for i in range(num_towns):\\r\\n town = {\\r\\n \\\"town_id\\\": i,\\r\\n \\\"name\\\": towns_dictionary[i],\\r\\n \\\"garbage\\\": math.floor(random.uniform(1, 50))\\r\\n }\\r\\n towns.append(town)\\r\\n\\r\\n for i in range(num_towns):\\r\\n town_hazards = []\\r\\n for j in range(num_facilities):\\r\\n town_hazards.append(math.floor(random.uniform(1, 100)))\\r\\n hazards.append(town_hazards)\\r\\n\\r\\n data = {\\r\\n \\\"towns\\\": towns,\\r\\n \\\"facilities\\\": facilities,\\r\\n \\\"hazards\\\": hazards\\r\\n }\\r\\n\\r\\n with open(f\\\"./instances/{file_name}.json\\\", 'w') as outfile:\\r\\n json.dump(data, outfile)\\r\\n\\r\\n return True\",\n \"def trial_prep(self):\\n pass\",\n \"def make_random_tiles(sx=500, sy=500, sz=0, nb=50, noise_sigma=None,\\n regular=True, double_pattern_y=False, double_pattern_z=False, \\n assym_y=True, assym_z=True, return_image=False):\\n \\n if sz == 0:\\n image = np.zeros((sy, sx))\\n # to overcome an issue with odd nb:\\n nb = int(np.ceil(nb / 2) * 2)\\n \\n if regular:\\n x = np.linspace(start=0, stop=sx-1, num=nb, dtype=int)\\n x = np.hstack((x[::2], x[1::2]))\\n if assym_y:\\n nb = nb*2\\n y = np.linspace(start=0, stop=sy-1, num=nb, dtype=int)\\n if double_pattern_y:\\n y = np.hstack((y[::2], y[1::2]))\\n x_id = np.tile(x, y.size//2)\\n y_id = np.repeat(y, x.size//2)\\n else:\\n x_id = np.random.randint(sx, size=nb)\\n y_id = np.random.randint(sy, size=nb)\\n \\n if noise_sigma is not None:\\n x_id = x_id + np.random.normal(loc=0.0, scale=noise_sigma, size=x_id.size)\\n x_id[x_id<0] = 0\\n x_id[x_id>sx-1] = sx-1\\n x_id = np.round(x_id).astype(int)\\n y_id = y_id + np.random.normal(loc=0.0, scale=noise_sigma, size=y_id.size)\\n y_id[y_id<0] = 0\\n y_id[y_id>sy-1] = sy-1\\n y_id = np.round(y_id).astype(int)\\n \\n coords = np.vstack((x_id, y_id)).T\\n image[y_id, x_id] = 1\\n masks = segmentation.watershed(-image)\\n else:\\n # make 3D simulation\\n image = np.zeros((sz, sy, sx))\\n # to overcome an issue with odd nb:\\n nb = int(np.ceil(nb / 2) * 2)\\n \\n if regular:\\n x = np.linspace(start=0, stop=sx-1, num=nb, dtype=int)\\n x = np.hstack((x[::2], x[1::2]))\\n if assym_y:\\n nb_y = nb*2\\n y = np.linspace(start=0, stop=sy-1, num=nb_y, dtype=int)\\n if assym_z:\\n nb_z = nb*2\\n z = np.linspace(start=0, stop=sz-1, num=nb_z, dtype=int)\\n if double_pattern_y:\\n y = np.hstack((y[::2], y[1::2]))\\n if double_pattern_z:\\n z = np.hstack((z[::2], z[1::2]))\\n x_id = np.tile(x, y.size//2)\\n y_id = np.repeat(y, x.size//2)\\n z_id = np.repeat(z, x.size//2)\\n else:\\n x_id = np.random.randint(sx, size=nb)\\n y_id = np.random.randint(sy, size=nb)\\n z_id = np.random.randint(sz, size=nb)\\n \\n if noise_sigma is None:\\n print(\\\"For 3D simulations noise_sigma needs to be > 0\\\")\\n print(\\\"Setting noise_sigma to 1\\\")\\n noise_sigma = 1\\n # x\\n x_id = x_id + np.random.normal(loc=0.0, scale=noise_sigma, size=x_id.size)\\n x_id[x_id<0] = 0\\n x_id[x_id>sx-1] = sx-1\\n x_id = np.round(x_id).astype(int)\\n # y\\n y_id = y_id + np.random.normal(loc=0.0, scale=noise_sigma, size=y_id.size)\\n y_id[y_id<0] = 0\\n y_id[y_id>sy-1] = sy-1\\n y_id = np.round(y_id).astype(int)\\n # z\\n z_id = z_id + np.random.normal(loc=0.0, scale=noise_sigma, size=z_id.size)\\n z_id[z_id<0] = 0\\n z_id[z_id>sz-1] = sz-1\\n z_id = np.round(z_id).astype(int)\\n \\n coords = np.vstack((x_id, y_id, z_id)).T\\n image[z_id, y_id, x_id] = 1\\n masks = segmentation.watershed(-image)\\n\\n if return_image:\\n return coords, masks, image\\n else:\\n return coords, masks\",\n \"def __generate_slices_a_set(self, set_id):\\n image_set_path = os.path.join(self.__data_dir, set_id)\\n os.chdir(image_set_path)\\n try:\\n os.mkdir(self.__new_dir_name)\\n except FileExistsError:\\n print('Directory already exist! Pass making new directory.')\\n slice_dir = os.path.join(image_set_path, self.__new_dir_name)\\n image_dir = os.path.join(image_set_path, 'normal')\\n texts = os.listdir(image_dir)\\n os.chdir(image_dir)\\n for text in texts:\\n if text.endswith('txt'):\\n image_name = text.split('.')[0]\\n # image_path = os.path.join(image_dir, '{}.jpg'.format(image_name))\\n points = []\\n count = 0\\n with open(text, 'r') as f:\\n for line in f.readlines():\\n line = line.strip()\\n points.append(line.split(' '))\\n cv_image = cv2.imread(\\\"{}.jpg\\\".format(image_name))\\n for point in points:\\n count += 1\\n x = int(point[0])\\n y = int(point[1])\\n a_slice = cv_image[\\n x - self.__width:\\n x + self.__width,\\n y - self.__width:\\n y + self.__width]\\n new_dir = os.path.join(slice_dir, '{0}_p{1}.jpg'.format(image_name, count))\\n cv2.imwrite(new_dir, a_slice)\",\n \"def main():\\n import shutil\\n import json\\n\\n if not os.path.isdir(args.cache):\\n # creation dossier cache\\n os.mkdir(args.cache)\\n\\n if not os.path.exists(args.cache+'/overviews.json'):\\n # creation fichier overviews.json a partir d'un fichier ressource\\n shutil.copy2(args.overviews, args.cache+'/overviews.json')\\n\\n with open(args.cache+'/overviews.json') as json_overviews:\\n overviews_dict = json.load(json_overviews)\\n if not (\\\"list_OPI\\\" in overviews_dict):\\n overviews_dict[\\\"list_OPI\\\"] = []\\n\\n out_raster_srs = gdal.osr.SpatialReference()\\n out_raster_srs.ImportFromEPSG(overviews_dict['crs']['code'])\\n conn_string = \\\"PG:host=\\\"+host+\\\" dbname=\\\"+database+\\\" user=\\\"+user+\\\" password=\\\"+password\\n db_graph = gdal.OpenEx(conn_string, gdal.OF_VECTOR)\\n if db_graph is None:\\n raise ValueError(\\\"Connection to database failed\\\")\\n list_filename = glob.glob(args.input)\\n if verbose > 0:\\n print(len(list_filename), \\\"fichier(s) a traiter\\\")\\n\\n try:\\n with open(args.cache+'/cache_mtd.json', 'r') as inputfile:\\n mtd = json.load(inputfile)\\n except:\\n mtd = {}\\n\\n cliche_dejaTraites = []\\n for filename in list_filename:\\n cliche = Path(filename).stem\\n \\n if (cliche in overviews_dict['list_OPI']):\\n # OPI déja traitée\\n cliche_dejaTraites.append(cliche)\\n else:\\n print('nouvelle image: ', filename)\\n color = [randrange(255), randrange(255), randrange(255)]\\n while (color[0] in mtd) and (color[1] in mtd[color[0]]) and (color[2] in mtd[color[0]][color[1]]):\\n color = [randrange(255), randrange(255), randrange(255)]\\n if color[0] not in mtd:\\n mtd[color[0]] = {}\\n if color[1] not in mtd[color[0]]:\\n mtd[color[0]][color[1]] = {}\\n mtd[color[0]][color[1]][color[2]] = cliche\\n process_image(overviews_dict, db_graph, filename, color, out_raster_srs)\\n # on ajout l'OPI traitée a la liste\\n overviews_dict[\\\"list_OPI\\\"].append(cliche)\\n\\n with open(args.cache+'/cache_mtd.json', 'w') as outfile:\\n json.dump(mtd, outfile)\\n\\n with open(args.cache+'/overviews.json', 'w') as outfile:\\n json.dump(overviews_dict, outfile)\\n\\n print(\\\"\\\\n\\\", len(list_filename) - len(cliche_dejaTraites),\\\"/\\\",len(list_filename),\\\"OPI(s) ajoutée(s)\\\")\\n if len(cliche_dejaTraites) > 0:\\n print(cliche_dejaTraites, \\\"déjà traitées : OPI non recalculée(s)\\\")\",\n \"def main():\\n\\ttile_dimensions = (512, 512)\\n\\ttile_count = (5, 4) \\n\\timage = Image.new(\\\"RGB\\\", (tile_dimensions[0] * tile_count[0], tile_dimensions[1] * tile_count[1]), None)\\n\\n\\ttry:\\n\\t\\turl = sys.argv[1]\\n\\texcept:\\n\\t\\tprint \\\"Please enter a Google Maps URL as a parameter.\\\"\\n\\t\\tprint \\\"Usage: $ python get_pano.py https://www.google.com/maps/@34.1027387,-118.340471,3a,75y,32.1h,87.53t/data=!3m7!1e1!3m5!1soInaTCic7TsAAAQDMaZ31A!2e0!3e2!7i13312!8i6656\\\"\\n\\t\\treturn\\n\\n\\ttry:\\n\\t\\tprint \\\"************************************\\\"\\n\\t\\tprint \\\"Fetching images from Google Maps, this could take some time...\\\"\\n\\t\\tregex = re.compile(r'panoid\\\\=([^&]*)', re.I)\\n\\t\\tpano_id = regex.findall(urllib.unquote(url))[0]\\n\\t\\tfor y in range(tile_count[1]):\\n\\t\\t\\tfor x in range(tile_count[0]):\\n\\t\\t\\t\\timg_url = \\\"https://geo2.ggpht.com/cbk?cb_client=maps_sv.tactile&authuser=0&hl=en&panoid=\\\" + pano_id + \\\"&output=tile&x=\\\"+str(x)+\\\"&y=\\\"+str(y)+\\\"&zoom=3&nbt&fover=2\\\"\\n\\t\\t\\t\\tresponse = urllib2.urlopen(img_url)\\n\\t\\t\\t\\tfile_data = StringIO(response.read())\\n\\t\\t\\t\\timage.paste(Image.open(file_data), (x * tile_dimensions[0], y * tile_dimensions[1]))\\n\\t\\t\\n\\t\\tfilename = \\\"pano-\\\" + pano_id + \\\".jpg\\\"\\n\\t\\timage.save(filename)\\n\\t\\tprint \\\"Success, image saved as \\\\033[96m\\\" + filename + \\\"\\\\033[00m\\\"\\n\\t\\tprint \\\"************************************\\\"\\n\\n\\n\\texcept Exception as e:\\n\\t\\tprint \\\"Sorry something broke.\\\"\\n\\t\\tprint e\",\n \"def sample_trajectories(env_teacher, env_student, policy_teacher, policy_student, min_timesteps_per_batch, max_path_length, render=False, render_mode=('rgb_array')):\\n\\n # TODO: GETTHIS from HW1\\n timesteps_this_batch = 0\\n paths_t, paths_s = [], []\\n while timesteps_this_batch < min_timesteps_per_batch:\\n path_teacher, path_student = sample_trajectory(env_teacher, env_student, policy_teacher, policy_student, max_path_length, render, render_mode)\\n paths_t.append(path_teacher)\\n paths_s.append(path_student)\\n timesteps_this_batch += get_pathlength(path_teacher) + get_pathlength(path_student)\\n\\n #print(\\\"OBS\\\")\\n #print([p[\\\"observation\\\"].shape for p in paths_s])\\n return paths_t, paths_s, timesteps_this_batch\",\n \"def generate_one(self, n_images, min_correct=None, p_correct=0.5, n_correct=None, n_caps_per_image=1, configs=None):\\n random.seed() # For multiprocessing (TODO: can we avoid this?)\\n imgs = np.zeros((n_images, 3, c.DIM, c.DIM), dtype=np.uint8)\\n labels = np.zeros((n_images, ), dtype=np.uint8)\\n if configs is not None:\\n cfg_idx = random.choice(len(configs))\\n target_cfg = configs[cfg_idx]\\n else:\\n # FIXME: Make this OOP to avoid these if statements\\n if self.img_type == 'spatial':\\n target_cfg = self.random_config_spatial()\\n elif self.img_type == 'single':\\n target_cfg = self.random_config_single()\\n\\n if self.data_type == 'concept':\\n if n_correct is not None:\\n # Fixed number of targets and distractors\\n n_target = n_correct\\n n_distract = n_images - n_target\\n elif min_correct is not None:\\n # Minimum number of targets, otherwise sample whatever\\n # TODO: combine min_correct and min_incorrect\\n n_target = min_correct\\n n_distract = 0\\n else:\\n # Minimum of 2 targets and distractors each\\n n_target = 2\\n n_distract = 2\\n else:\\n n_target = 1\\n n_distract = n_images # Never run out of distractors\\n\\n cfgs = []\\n shapes = []\\n cfgs_to_cap = []\\n for i in range(n_images):\\n if n_target > 0:\\n label = 1\\n n_target -= 1\\n elif n_distract > 0:\\n label = 0\\n n_distract -= 1\\n else:\\n label = (random.random() < p_correct)\\n\\n if self.img_type == 'spatial':\\n new_cfg, new_shapes, cfg_to_cap = self.generate_spatial(target_cfg, label, n_caps_per_image)\\n elif self.img_type == 'single':\\n new_cfg, new_shapes = self.generate_single(target_cfg, label)\\n\\n # Create image and draw shapes\\n img = self.create_image(new_shapes)\\n imgs[i] = img\\n labels[i] = label\\n cfgs.append(new_cfg)\\n shapes.append(new_shapes)\\n cfgs_to_cap.append(cfg_to_cap)\\n\\n return imgs, labels, target_cfg, cfgs, cfgs_to_cap, shapes\",\n \"def new_robot_images(images): #py:new_robot_images\\n RUR._new_robot_images_(images)\",\n \"def training_data_generation(DATA_DIR, img_height_size, img_width_size, label_list):\\r\\n \\r\\n img_ms_files = glob.glob(DATA_DIR + '\\\\\\\\Train_MS' + '\\\\\\\\Train_*.tif')\\r\\n img_pan_files = glob.glob(DATA_DIR + '\\\\\\\\Train_Pan' + '\\\\\\\\Train_*.tif')\\r\\n polygon_files = glob.glob(DATA_DIR + '\\\\\\\\Train_Polygons' + '\\\\\\\\Train_*.geojson')\\r\\n \\r\\n img_ms_array_list = []\\r\\n img_pan_array_list = []\\r\\n mask_array_list = []\\r\\n \\r\\n for file in range(len(img_ms_files)):\\r\\n with rasterio.open(img_ms_files[file]) as f:\\r\\n metadata = f.profile\\r\\n img_ms = np.transpose(f.read(tuple(np.arange(metadata['count']) + 1)), [1, 2, 0])\\r\\n \\r\\n with rasterio.open(img_pan_files[file]) as g:\\r\\n metadata_pan = g.profile\\r\\n img_pan = np.expand_dims(g.read(1), axis = 2)\\r\\n \\r\\n ms_to_pan_ratio = metadata['transform'][0] / metadata_pan['transform'][0]\\r\\n \\r\\n if (img_height_size % ms_to_pan_ratio) != 0 or (img_width_size % ms_to_pan_ratio) != 0:\\r\\n raise ValueError('Please make sure that both img_height_size and img_width_size can be divided by {}'.format(int(ms_to_pan_ratio)))\\r\\n \\r\\n mask = training_mask_generation(img_pan_files[file], polygon_files[file], labels = label_list)\\r\\n \\r\\n img_ms_array, img_pan_array, mask_array = image_clip_to_segment_and_convert(img_ms, img_pan, mask, ms_to_pan_ratio, \\r\\n img_height_size, img_width_size)\\r\\n \\r\\n img_ms_array_list.append(img_ms_array)\\r\\n img_pan_array_list.append(img_pan_array)\\r\\n mask_array_list.append(mask_array)\\r\\n \\r\\n img_ms_full_array = np.concatenate(img_ms_array_list, axis = 0)\\r\\n img_pan_full_array = np.concatenate(img_pan_array_list, axis = 0)\\r\\n mask_full_array = to_categorical(np.concatenate(mask_array_list, axis = 0), num_classes = len(label_list))\\r\\n \\r\\n return img_ms_full_array, img_pan_full_array, mask_full_array\",\n \"def tst_random_set():\\n final_wave, final_spec, final_z = desi_qso_templates(\\n outfil='test_random_set.fits', N_perz=100, seed=12345)\",\n \"def run_experiments() :\\n #%%\\n target_size=(32,32)\\n g_specs = {\\n \\\"batch_size\\\" : [ 30 , 60, 100 ],\\n \\\"learning_rate\\\" : [ 0.0002, 0.0003, 0.0005 ],\\n \\\"drop_out_rate\\\" : [ 0.2, 0.25, 0.3 ],\\n \\\"rescale_mode\\\" : [ \\\"max_q\\\" , \\\"max\\\", \\\"\\\" ]\\n }\\n\\n model_traits = MODEL_TRAITS[\\\"model2\\\"].copy()\\n tt_obj = model_traits[\\\"trainer_tester_class\\\"]( model_traits )\\n del model_traits[\\\"trainer_tester_class\\\"]\\n\\n cnt = 0\\n for batchs, lrate, do_rate, resc_mode in product( g_specs[\\\"batch_size\\\"],\\n g_specs[\\\"learning_rate\\\"],\\n g_specs[\\\"drop_out_rate\\\"],\\n g_specs[\\\"rescale_mode\\\"] ) :\\n\\n tt_obj.model_traits.update( {\\\"batch_size\\\" : batchs,\\n \\\"learning_rate\\\" : lrate,\\n \\\"rescale_mode\\\" : resc_mode,\\n \\\"drop_out_rate\\\" : do_rate } )\\n\\n train_4d, train_gt = tu.make_4d_arrays( images_dir=\\\"images/train\\\",\\n target_size=target_size )\\n\\n test_4d, test_gt = tu.make_4d_arrays( images_dir=\\\"images/test\\\",\\n target_size=target_size )\\n\\n data = {\\\"train_4d\\\" : train_4d,\\n \\\"test_4d\\\" : test_4d,\\n \\\"train_y\\\" : train_gt,\\n \\\"test_y\\\" : test_gt}\\n\\n valid_accu_log, train_accu_log = tt_obj.train( model_traits, data,\\n logl=100 )\\n idx_v = int(np.argmax( valid_accu_log))\\n idx_t = int(np.argmax( train_accu_log))\\n\\n model_traits.update({\\\"valid_accu_log\\\" : valid_accu_log,\\n \\\"train_accu_log\\\" : train_accu_log,\\n \\\"best_valid\\\" : max(valid_accu_log),\\n \\\"best_valid_at\\\" : idx_v,\\n \\\"train_at_best_valid\\\" : train_accu_log[idx_v],\\n \\\"best_train\\\" : max(train_accu_log),\\n \\\"best_train_at\\\": idx_t })\\n\\n #print(cnt, pformat(model_traits) )\\n print( \\\"%d : best_train = %.4f, best_valid = %.4f\\\" % \\\\\\n (cnt, max(train_accu_log), max(valid_accu_log) ))\\n\\n with open( \\\"exp_results_%d.json\\\" % cnt,\\n \\\"wt\\\" , encoding=\\\"utf8\\\" ) as f_out :\\n print( json.dumps( model_traits ), file=f_out)\\n\\n\\n cnt += 1\\n #%%\",\n \"def trial_table():\\n # Read data\\n included = read_npy_file('trials.included.npy')\\n fb_type = read_npy_file('trials.feedbackType.npy')\\n fb_type = fb_type.astype(int)\\n fb_time = read_npy_file('trials.feedback_times.npy')\\n go_cue = read_npy_file('trials.goCue_times.npy')\\n trial_intervals = read_npy_file('trials.intervals.npy')\\n rep_num = read_npy_file('trials.repNum.npy')\\n response_choice = read_npy_file('trials.response_choice.npy')\\n response_times = read_npy_file('trials.response_times.npy')\\n visual_left = read_npy_file('trials.visualStim_contrastLeft.npy')\\n visual_right = read_npy_file('trials.visualStim_contrastRight.npy')\\n visual_times = read_npy_file('trials.visualStim_times.npy')\\n\\n for j in range(len(trial_intervals)):\\n nwb_file.add_trial(trial_intervals[j, 0], trial_intervals[j, 1])\\n\\n nwb_file.add_trial_column(\\n 'included',\\n 'Importantly, while this variable gives inclusion criteria according '\\n 'to the definition of disengagement (see manuscript Methods), it does '\\n 'not give inclusion criteria based on the time of response, as used '\\n 'for most analyses in the paper.',\\n np.ravel(included)\\n )\\n nwb_file.add_trial_column(\\n 'go_cue',\\n 'The \\\\'goCue\\\\' is referred to as the \\\\'auditory tone cue\\\\' in the manuscript.',\\n np.ravel(go_cue)\\n )\\n nwb_file.add_trial_column(\\n 'visual_stimulus_time',\\n 'Times are relative to the same time base as every other time in the dataset, '\\n 'not to the start of the trial.',\\n np.ravel(visual_times)\\n )\\n nwb_file.add_trial_column(\\n 'visual_stimulus_left_contrast',\\n 'Proportion contrast. A value of 0.5 means 50% contrast. 0 is a blank '\\n 'screen: no change to any pixel values on that side (completely undetectable).',\\n np.ravel(visual_left)\\n )\\n nwb_file.add_trial_column(\\n 'visual_stimulus_right_contrast',\\n 'Proportion contrast. A value of 0.5 means 50% contrast. 0 is a blank '\\n 'screen: no change to any pixel values on that side (completely undetectable).',\\n np.ravel(visual_right)\\n )\\n nwb_file.add_trial_column(\\n 'response_time',\\n 'Times are relative to the same time base as every other time in the dataset, '\\n 'not to the start of the trial.',\\n np.ravel(response_times)\\n )\\n nwb_file.add_trial_column(\\n 'response_choice',\\n 'Enumerated type. The response registered at the end of the trial, '\\n 'which determines the feedback according to the contrast condition. '\\n 'Note that in a small percentage of cases (~4%, see manuscript Methods) '\\n 'the initial wheel turn was in the opposite direction. -1 for Right '\\n 'choice (i.e. correct when stimuli are on the right); +1 for left '\\n 'choice; 0 for Nogo choice.',\\n np.ravel(response_choice)\\n )\\n nwb_file.add_trial_column(\\n 'feedback_time',\\n 'Times are relative to the same time base as every other time in the dataset, '\\n 'not to the start of the trial.',\\n np.ravel(fb_time)\\n )\\n nwb_file.add_trial_column(\\n 'feedback_type',\\n 'Enumerated type. -1 for negative feedback (white noise burst); +1 for '\\n 'positive feedback (water reward delivery).',\\n np.ravel(fb_type)\\n )\\n nwb_file.add_trial_column(\\n 'rep_num',\\n 'Trials are repeated if they are \\\"easy\\\" trials (high contrast stimuli '\\n 'with large difference between the two sides, or the blank screen '\\n 'condition) and this keeps track of how many times the current '\\n 'trial\\\\'s condition has been repeated.',\\n np.ravel(rep_num)\\n )\",\n \"def three_sample_images():\\n samples = samples_path()\\n _truck = np.array(Image.open(os.path.join(samples, \\\"truck.png\\\")))\\n _deer = np.array(Image.open(os.path.join(samples, \\\"deer.png\\\")))\\n _frog = np.array(Image.open(os.path.join(samples, \\\"frog.png\\\")))\\n truck = transforms.ToTensor()(_truck)\\n deer = transforms.ToTensor()(_deer)\\n frog = transforms.ToTensor()(_frog)\\n return torch.stack([truck, deer, frog])\",\n \"def prep_synthetic_test(self, outdir='synthetic_test',\\n loc=(300,350,50,100), #t89\\n signal='linear', #sinusoidal, exponential?\\n rate=0.01, #(m)\\n noise=None, #white, colored (correlated)?\\n ramp=None): #linear, quadratic?\\n if os.path.isdir(outdir):\\n shutil.rmtree(outdir)\\n os.mkdir(outdir)\\n\\n shape = self.Set.Shape\\n ind_signal = np.zeros(shape, dtype='bool')\\n ind_signal[loc[0]:loc[1],loc[2]:loc[3]] = 1\\n bd = 20\\n ind_bound = np.zeros_like(ind_signal)\\n ind_bound[loc[0]-bd:loc[1]+bd,loc[2]-bd:loc[3]+bd] = 1\\n ind_bound[ind_signal] = 0\\n\\n for ig in self.Set:\\n amp, phs = roipy.tools.load_bil(ig)\\n\\n # Create synthetic signal\\n phs_syn = np.zeros_like(phs)\\n phs_syn[ind_signal] = (rate * ig.Timespan)\\n\\n # Create transition zone\\n phs_syn[ind_bound] = (0.01 * ig.Timespan)\\n\\n # Add noise\\n if noise != None:\\n noise = add_noise(noise)\\n phs_syn += noise\\n\\n # Add ramps\\n if ramp != None:\\n surface = make_surface(ramp)\\n phs_syn += surface\\n\\n # Save Data & Rsc\\n phs_syn = phs_syn * (4*np.pi/ig.Wavelength) #convert to phase\\n outpath = os.path.join(outdir,ig.Name.replace('rect_','rect_synthetic_'))\\n roipy.tools.save_bil(ig, outpath, amp, phs_syn)\\n #roipy.tools.save_rsc(ig.Rsc, outpath + '.rsc') #automatically called\\n\\n print('synthetic test set up in:\\\\n{}'.format(os.path.abspath(outdir)))\",\n \"def fully_sample_sky(region = \\\"allsky\\\", limitregion = False, adaptivep0 = True, useprior = \\\"RHTPrior\\\", velrangestring = \\\"-10_10\\\", \\n gausssmooth_prior = False, tol=1E-5, sampletype = \\\"mean_bayes\\\", mcmc=False, deltafuncprior=False, testpsiproj=False, \\n testthetas=False, save=True, baseprioramp = 1E-8, smoothprior=False, sig=30, fixwidth=False):\\n \\n print(\\\"Fully sampling sky with options: region = {}, limitregion = {}, useprior = {}, velrangestring = {}, gausssmooth_prior = {}, deltafuncprior = {}, testpsiproj = {}, testthetas = {}\\\".format(region, limitregion, useprior, velrangestring, gausssmooth_prior, deltafuncprior, testpsiproj, testthetas))\\n\\n out_root = \\\"/disks/jansky/a/users/goldston/susan/Wide_maps/\\\"\\n\\n # Get ids of all pixels that contain RHT data\\n rht_cursor, tablename = get_rht_cursor(region = region, velrangestring = velrangestring)\\n print(\\\"table name is\\\", tablename)\\n all_ids = get_all_rht_ids(rht_cursor, tablename)\\n \\n if limitregion is True:\\n print(\\\"Loading all allsky data points that are in the SC_241 region\\\")\\n # Get all ids that are in both allsky data and SC_241\\n all_ids_SC = pickle.load(open(\\\"SC_241_healpix_ids.p\\\", \\\"rb\\\"))\\n all_ids = list(set(all_ids).intersection(all_ids_SC))\\n \\n print(\\\"beginning creation of all posteriors\\\")\\n \\n if testthetas is False:\\n # Create and sample posteriors for all pixels\\n if useprior is \\\"RHTPrior\\\":\\n all_pMB, all_psiMB = sample_all_rht_points(all_ids, adaptivep0 = adaptivep0, rht_cursor = rht_cursor, region = region, useprior = useprior, gausssmooth_prior = gausssmooth_prior, tol=tol, sampletype = sampletype, mcmc = mcmc, deltafuncprior=deltafuncprior, testpsiproj=testpsiproj, baseprioramp=baseprioramp)\\n elif useprior is \\\"ThetaRHT\\\":\\n all_pMB, all_psiMB = sample_all_rht_points_ThetaRHTPrior(all_ids, adaptivep0 = adaptivep0, region = region, useprior = useprior, local = False, tol=tol, smoothprior=smoothprior, sig=sig, fixwidth=fixwidth)\\n \\n # Place into healpix map\\n hp_psiMB = make_hp_map(all_psiMB, all_ids, Nside = 2048, nest = True)\\n hp_pMB = make_hp_map(all_pMB, all_ids, Nside = 2048, nest = True)\\n \\n if limitregion is False:\\n psiMB_out_fn = \\\"psiMB_allsky_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\".fits\\\"\\n pMB_out_fn = \\\"pMB_allsky_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\".fits\\\"\\n elif limitregion is True:\\n if mcmc is True:\\n psiMB_out_fn = \\\"psiMB_DR2_SC_241_mcmc_50_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_tol_{}.fits\\\".format(tol)\\n pMB_out_fn = \\\"pMB_DR2_SC_241_mcmc_50_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_tol_{}.fits\\\".format(tol)\\n else:\\n if sampletype is \\\"mean_bayes\\\":\\n print(\\\"saving mean bayes sampled planck+rht data\\\")\\n #psiMB_out_fn = \\\"psiMB_DR2_SC_241_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_tol_{}.fits\\\".format(tol)\\n #pMB_out_fn = \\\"pMB_DR2_SC_241_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_tol_{}.fits\\\".format(tol)\\n #psiMB_out_fn = \\\"psiMB_DR2_SC_241_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_deltafuncprior_\\\"+str(deltafuncprior)+\\\"_fixedpsi0_reverseRHT.fits\\\"\\n #pMB_out_fn = \\\"pMB_DR2_SC_241_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_deltafuncprior_\\\"+str(deltafuncprior)+\\\"_fixedpsi0_reverseRHT.fits\\\"\\n if useprior is \\\"RHTPrior\\\":\\n psiMB_out_fn = \\\"psiMB_DR2_SC_241_prior_\\\"+useprior+\\\"_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_deltafuncprior_\\\"+str(deltafuncprior)+\\\"_baseprioramp_\\\"+str(baseprioramp)+\\\".fits\\\"\\n pMB_out_fn = \\\"pMB_DR2_SC_241_prior_\\\"+useprior+\\\"_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_deltafuncprior_\\\"+str(deltafuncprior)+\\\"_baseprioramp_\\\"+str(baseprioramp)+\\\".fits\\\"\\n elif useprior is \\\"ThetaRHT\\\":\\n psiMB_out_fn = \\\"psiMB_DR2_SC_241_prior_\\\"+useprior+\\\"_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(smoothprior)+\\\"_sig_\\\"+str(sig)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_fixwidth_\\\"+str(fixwidth)+\\\".fits\\\"\\n pMB_out_fn = \\\"pMB_DR2_SC_241_prior_\\\"+useprior+\\\"_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(smoothprior)+\\\"_sig_\\\"+str(sig)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_fixwidth_\\\"+str(fixwidth)+\\\".fits\\\"\\n \\n \\n elif sampletype is \\\"MAP\\\":\\n psiMB_out_fn = \\\"psiMB_MAP_DR2_SC_241_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_baseprioramp_\\\"+str(baseprioramp)+\\\".fits\\\"\\n pMB_out_fn = \\\"pMB_MAP_DR2_SC_241_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_baseprioramp_\\\"+str(baseprioramp)+\\\".fits\\\"\\n \\n if testpsiproj is True:\\n psiMB_out_fn = \\\"psiMB_DR2_SC_241_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_deltafuncprior_\\\"+str(deltafuncprior)+\\\"_testpsiproj_\\\"+str(testpsiproj)+\\\"_smalloffset.fits\\\"\\n pMB_out_fn = \\\"pMB_DR2_SC_241_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_deltafuncprior_\\\"+str(deltafuncprior)+\\\"_testpsiproj_\\\"+str(testpsiproj)+\\\"_smalloffset.fits\\\"\\n \\n if save:\\n hp.fitsfunc.write_map(out_root + psiMB_out_fn, hp_psiMB, coord = \\\"G\\\", nest = True) \\n hp.fitsfunc.write_map(out_root + pMB_out_fn, hp_pMB, coord = \\\"G\\\", nest = True) \\n else:\\n all_maxrhts, zzz = sample_all_rht_points(all_ids, adaptivep0 = adaptivep0, rht_cursor = rht_cursor, region = region, useprior = useprior, gausssmooth_prior = gausssmooth_prior, tol=tol, sampletype = sampletype, mcmc = mcmc, deltafuncprior=deltafuncprior, testpsiproj=testpsiproj, testthetas=testthetas)\\n maxrhts = make_hp_map(all_maxrhts, all_ids, Nside = 2048, nest = True)\\n hp.fitsfunc.write_map(out_root + \\\"vel_\\\" + velrangestring +\\\"_maxrht.fits\\\", maxrhts, coord = \\\"G\\\", nest = True)\",\n \"def load_tamper(self, dataset_dir, subset):\\n # Add classes. We have one class.\\n # Naming the dataset nucleus, and the class nucleus\\n self.add_class(\\\"tampers\\\", 1, \\\"tampers\\\")\\n\\n # Which subset?\\n # \\\"val\\\": use hard-coded list above\\n # \\\"train\\\": use data from stage1_train minus the hard-coded list above\\n # else: use the data from the specified sub-directory\\n # assert subset in [\\\"train\\\", \\\"val\\\", \\\"stage1_train\\\", \\\"stage1_test\\\", \\\"stage2_test\\\"]\\n # subset_dir = \\\"stage1_train\\\" if subset in [\\\"train\\\", \\\"val\\\"] else subset\\n dataset_dir = os.path.join(dataset_dir, subset, 'images')\\n if subset == \\\"val\\\" or subset == \\\"test\\\":\\n image_ids = next(os.walk(dataset_dir))[2]\\n else:\\n # Get image ids from directory names\\n image_ids = next(os.walk(dataset_dir))[2]\\n \\n\\n # dircopy_move = '/data/twj/copy-move/data_zoo/dataset/images/train'\\n # image_ids_copy_move = next(os.walk(os.path.join(dircopy_move, 'images')))[2]\\n\\n # dirnew_splicing = '/data/tamper'\\n # image_ids_new_splicing = next(os.walk(os.path.join(dirnew_splicing, 'images')))[2]\\n\\n # dircopy_move = '/home/as/deeplab/wpmrcnn/ca2new/test'\\n # image_ids_copy_move = next(os.walk(os.path.join(dircopy_move, 'images')))[2]\\n\\n \\n # dircopy_move = '/data/gy/ca2att/train3'\\n # image_ids_copy_move = next(os.walk(os.path.join(dircopy_move, 'images')))[2]\\n\\n # # # dirtxt_sp = '/data/gy/tamperpre/train'\\n # # # image_ids_txt_sp = next(os.walk(os.path.join(dirtxt_sp, 'images')))[2]\\n\\n # dirnew_sp = '/data/gy/c2newsp/train'\\n # image_ids_new_sp = next(os.walk(os.path.join(dirnew_sp, 'images')))[2]\\n\\n # Add images\\n for image_id in image_ids:\\n self.add_image(\\n \\\"tampers\\\",\\n image_id=image_id[:-4],\\n path=os.path.join(dataset_dir, image_id))\\n\\n # for image_id in image_ids_copy_move:\\n # self.add_image(\\n # \\\"tampers\\\",\\n # image_id=image_id[:-4],\\n # path=os.path.join(dircopy_move, 'images', image_id))\\n\\n # for image_id in image_ids_new_splicing:\\n # self.add_image(\\n # \\\"tampers\\\",\\n # image_id=image_id[:-4],\\n # path=os.path.join(dirnew_splicing, 'images', image_id))\\n\\n # # for image_id in image_ids_txt_sp:\\n # # self.add_image(\\n # # \\\"tampers\\\",\\n # # image_id=image_id[:-4],\\n # # path=os.path.join(dirtxt_sp, 'images', image_id))\\n\\n # for image_id in image_ids_new_sp:\\n # self.add_image(\\n # \\\"tampers\\\",\\n # image_id=image_id[:-4],\\n # path=os.path.join(dirnew_sp, 'images', image_id))\",\n \"def generate_tfrecords(image_dirs, resize_str, params, num_samples_per_rec=20):\\n print('Image folders:', image_dirs)\\n\\n # Iterate over image folders, processing each.\\n cam = params.camera\\n for image_dir in image_dirs:\\n print('Processing folder %s' % image_dir)\\n # Get data params, set new ones.\\n _, _, num_kp, cam_orig = utils.read_data_params(\\n os.path.join(image_dir, 'data_params.pbtxt'))\\n cam.baseline = cam_orig.baseline\\n params.num_kp = num_kp\\n out_dir = os.path.join(image_dir, resize_str)\\n os.makedirs(out_dir, exist_ok=True)\\n utils.write_to_text_file(os.path.join(out_dir, 'data_params.pbtxt'), params)\\n\\n # Read image files and generate tfrecords.\\n filenames_left = glob.glob(os.path.join(image_dir, '*_L.png'))\\n filenames_right = glob.glob(os.path.join(image_dir, '*_R.png'))\\n filenames_target_left = glob.glob(os.path.join(image_dir, '*_L.pbtxt'))\\n filenames_target_right = glob.glob(os.path.join(image_dir, '*_R.pbtxt'))\\n if not filenames_right:\\n filenames_right = filenames_left\\n filenames_target_right = filenames_target_left\\n else:\\n print('Have stereo images')\\n assert len(filenames_left) == len(filenames_target_left)\\n assert len(filenames_target_left) == len(filenames_target_right)\\n assert len(filenames_left) == len(filenames_right)\\n filenames_left.sort()\\n filenames_right.sort()\\n filenames_target_left.sort()\\n filenames_target_right.sort()\\n total = len(filenames_left)\\n print('Found %d total image examples' % total)\\n\\n j = 0\\n while j < total:\\n jj = min(total, j + num_samples_per_rec)\\n record_name = ('%04d' % j) + '.tfrecord'\\n print('Record file %s' % record_name)\\n path = os.path.join(out_dir, record_name)\\n print('Generating examples %d to %d' % (j, jj))\\n generate(path, cam_orig, cam, filenames_left[j:jj], filenames_right[j:jj],\\n filenames_target_left[j:jj], filenames_target_right[j:jj])\\n j = jj\",\n \"def getGoogleMap(self, lat, lng, wTileN, hTileN, zoom):\\n start_x, start_y = self.getStartTlXY(lat, lng, zoom)\\n width, height = 256 * wTileN, 256 * hTileN\\n map_img = Image.new('RGB', (width, height))\\n for x in range(0, wTileN):\\n for y in range(0, hTileN):\\n url = 'https://mt0.google.com/vt?x=' + \\\\\\n str(start_x+x)+'&y='+str(start_y+y)+'&z='+str(zoom)\\n current_tile = str(x)+'-'+str(y)\\n urllib.request.urlretrieve(url, current_tile)\\n map_img.paste(Image.open(current_tile), (x*256, y*256))\\n os.remove(current_tile)\\n return map_img\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6116985","0.6031568","0.5918441","0.5664884","0.5622315","0.5615459","0.5599443","0.5529613","0.55038154","0.54847896","0.5482034","0.5451923","0.5441349","0.5423713","0.5408815","0.5383447","0.5371646","0.5351493","0.53448683","0.5335508","0.52934724","0.5286916","0.52813494","0.5272756","0.5268043","0.52259815","0.51973027","0.5188907","0.51681256","0.51679724","0.51653826","0.51501393","0.515009","0.5150046","0.5139544","0.5138738","0.51334065","0.512046","0.5106728","0.5106087","0.50994086","0.50989616","0.508956","0.5089228","0.50862247","0.5076254","0.5065561","0.50645274","0.5057868","0.5057127","0.5055861","0.50512785","0.50476456","0.50405777","0.5031296","0.5025618","0.5023131","0.502238","0.5020672","0.50202334","0.5015744","0.50119084","0.5005023","0.500223","0.5001787","0.49925438","0.4981988","0.49757037","0.497189","0.49679464","0.49626106","0.49523136","0.49516293","0.49502087","0.4949748","0.4938109","0.49254075","0.49175182","0.49062407","0.4903389","0.49033618","0.49031827","0.489958","0.48994762","0.4897132","0.48927984","0.48896772","0.48886454","0.4886896","0.48794594","0.48771778","0.48760995","0.4875663","0.48734882","0.486713","0.48649362","0.48619077","0.4856494","0.48561487","0.48514956"],"string":"[\n \"0.6116985\",\n \"0.6031568\",\n \"0.5918441\",\n \"0.5664884\",\n \"0.5622315\",\n \"0.5615459\",\n \"0.5599443\",\n \"0.5529613\",\n \"0.55038154\",\n \"0.54847896\",\n \"0.5482034\",\n \"0.5451923\",\n \"0.5441349\",\n \"0.5423713\",\n \"0.5408815\",\n \"0.5383447\",\n \"0.5371646\",\n \"0.5351493\",\n \"0.53448683\",\n \"0.5335508\",\n \"0.52934724\",\n \"0.5286916\",\n \"0.52813494\",\n \"0.5272756\",\n \"0.5268043\",\n \"0.52259815\",\n \"0.51973027\",\n \"0.5188907\",\n \"0.51681256\",\n \"0.51679724\",\n \"0.51653826\",\n \"0.51501393\",\n \"0.515009\",\n \"0.5150046\",\n \"0.5139544\",\n \"0.5138738\",\n \"0.51334065\",\n \"0.512046\",\n \"0.5106728\",\n \"0.5106087\",\n \"0.50994086\",\n \"0.50989616\",\n \"0.508956\",\n \"0.5089228\",\n \"0.50862247\",\n \"0.5076254\",\n \"0.5065561\",\n \"0.50645274\",\n \"0.5057868\",\n \"0.5057127\",\n \"0.5055861\",\n \"0.50512785\",\n \"0.50476456\",\n \"0.50405777\",\n \"0.5031296\",\n \"0.5025618\",\n \"0.5023131\",\n \"0.502238\",\n \"0.5020672\",\n \"0.50202334\",\n \"0.5015744\",\n \"0.50119084\",\n \"0.5005023\",\n \"0.500223\",\n \"0.5001787\",\n \"0.49925438\",\n \"0.4981988\",\n \"0.49757037\",\n \"0.497189\",\n \"0.49679464\",\n \"0.49626106\",\n \"0.49523136\",\n \"0.49516293\",\n \"0.49502087\",\n \"0.4949748\",\n \"0.4938109\",\n \"0.49254075\",\n \"0.49175182\",\n \"0.49062407\",\n \"0.4903389\",\n \"0.49033618\",\n \"0.49031827\",\n \"0.489958\",\n \"0.48994762\",\n \"0.4897132\",\n \"0.48927984\",\n \"0.48896772\",\n \"0.48886454\",\n \"0.4886896\",\n \"0.48794594\",\n \"0.48771778\",\n \"0.48760995\",\n \"0.4875663\",\n \"0.48734882\",\n \"0.486713\",\n \"0.48649362\",\n \"0.48619077\",\n \"0.4856494\",\n \"0.48561487\",\n \"0.48514956\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7455843"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":24570,"cells":{"query":{"kind":"string","value":"Calculates the fuzzy match of needle in haystack, using a modified version of the Levenshtein distance algorithm. The function is modified from the levenshtein function in the bktree module by Adam Hupp"},"document":{"kind":"string","value":"def __fuzzy_substring(needle, haystack):\n m, n = len(needle), len(haystack)\n\n # base cases\n if m == 1:\n # return not needle in haystack\n row = [len(haystack)] * len(haystack)\n row[haystack.find(needle)] = 0\n return row\n if not n:\n return m\n\n row1 = [0] * (n + 1)\n for i in range(0, m):\n row2 = [i + 1]\n for j in range(0, n):\n cost = (needle[i] != haystack[j])\n\n row2.append(min(row1[j + 1] + 1, # deletion\n row2[j] + 1, # insertion\n row1[j] + cost) # substitution\n )\n row1 = row2\n return row1"},"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 levenshtein_normalised(str1, str2):\n\treturn levenshtein(str1, str2, normalise=True)","def levenshtein(str1, str2, normalise=False):\n\ttmp = Levenshtein.distance(str1, str2)\n\tif(normalise) and (len(str1) + len(str2)): tmp /= max(len(str1), len(str2))\n\treturn tmp","def get_closest_levenshtein(word, possible_words, threshold):\n result = None\n min_distance = 10\n for possible_word in possible_words:\n word_distance = distance(word, possible_word)\n if word_distance < min_distance:\n result = possible_word\n min_distance = word_distance\n result = result if min_distance < threshold else None\n return result, min_distance","def fuzzy_score_string(first_string, second_string):\n score = 0\n\n if len(first_string) < len(second_string):\n shorter, longer = (first_string, second_string)\n window_length = len(shorter)\n\n num_iterations = len(longer) - len(shorter) + 1\n\n for position in range(0, num_iterations):\n window = longer[position:position + window_length]\n l_ratio = Levenshtein.ratio(window, shorter) * 100\n\n if l_ratio > 60:\n result = statistics.mean(\n [100 - Levenshtein.distance(window, shorter) * 15, l_ratio, l_ratio])\n\n else:\n result = l_ratio\n\n if result > score:\n score = result\n\n else:\n l_ratio = Levenshtein.ratio(first_string, second_string) * 100\n score = statistics.mean(\n [100 - Levenshtein.distance(first_string, second_string) * 15, l_ratio, l_ratio])\n\n simple = fuzz.ratio(first_string, second_string)\n partial = fuzz.partial_ratio(first_string, second_string)\n sort = fuzz.token_sort_ratio(first_string, second_string)\n set_ratio = fuzz.token_set_ratio(first_string, second_string)\n\n score = max([score, simple, partial, sort, set_ratio])\n\n if score < 75:\n score = 0\n\n return score * 0.85","def levenshtein_distance(str1, str2):\n m = len(str1)\n n = len(str2)\n lensum = float(m + n)\n d = [] \n for i in range(m+1):\n d.append([i]) \n del d[0][0] \n for j in range(n+1):\n d[0].append(j) \n for j in range(1,n+1):\n for i in range(1,m+1):\n if str1[i-1] == str2[j-1]:\n d[i].insert(j,d[i-1][j-1]) \n else:\n minimum = min(d[i-1][j]+1, d[i][j-1]+1, d[i-1][j-1]+2) \n d[i].insert(j, minimum)\n ldist = d[-1][-1]\n ratio = (lensum - ldist)/lensum\n return {'distance':ldist, 'ratio':ratio}","def fuzzy_match_strings(ref, val):\n if not ref or not val:\n return 0\n ref_q = to_q(ref)\n val_q = to_q(val)\n if ref_q or val_q:\n return 100 if ref_q == val_q else 0\n simplified_val = unidecode(val).lower()\n simplified_ref = unidecode(ref).lower()\n\n # Return symmetric score\n r1 = fuzz.token_sort_ratio(simplified_val, simplified_ref)\n r2 = fuzz.token_sort_ratio(simplified_ref, simplified_val)\n r2 = r1\n return int(0.5*(r1+r2))","def levenshtein(s1, s2):\n if len(s1) < len(s2):\n return levenshtein(s2, s1)\n\n # len(s1) >= len(s2)\n if len(s2) == 0:\n return len(s1)\n\n previous_row = range(len(s2) + 1)\n for i, c1 in enumerate(s1):\n current_row = [i + 1]\n for j, c2 in enumerate(s2):\n insertions = previous_row[j + 1] + 1 # j+1 instead of j since previous_row and current_row are one character longer\n deletions = current_row[j] + 1 # than s2\n substitutions = previous_row[j] + (c1 != c2)\n current_row.append(min(insertions, deletions, substitutions))\n previous_row = current_row\n \n return previous_row[-1]","def levenshtein_distance(s1,s2):\n\n\t\tif len(s1) < len(s2):\n\t\t\treturn Searcher.levenshtein_distance(s2, s1)\n\n\t\t# len(s1) >= len(s2)\n\t\tif len(s2) == 0:\n\t\t\treturn len(s1)\n\n\t\tprevious_row = range(len(s2) + 1)\n\t\tfor i, c1 in enumerate(s1):\n\t\t\tcurrent_row = [i + 1]\n\t\t\tfor j, c2 in enumerate(s2):\n\t\t\t\tinsertions = previous_row[j + 1] + 1 # j+1 instead of j since previous_row and current_row are one character longer\n\t\t\t\tdeletions = current_row[j] + 1 # than s2\n\t\t\t\tsubstitutions = previous_row[j] + (c1 != c2)\n\t\t\t\tcurrent_row.append(min(insertions, deletions, substitutions))\n\t\t\tprevious_row = current_row\n\t\t\n\t\treturn previous_row[-1]","def mismatch_search(haystack, needle, mismatches=1):\n haystack = haystack.encode('utf-8');\n needle = needle.encode('utf-8');\n if not using_tre:\n raise RBSError(\"tre isn't loaded.\")\n fz = tre.Fuzzyness(maxerr=mismatches, maxsub=mismatches,\n maxdel=0, maxins=0)\n needle = \".*(%s).*\" % needle\n pt = tre.compile(needle, tre.EXTENDED)\n incidence = 0\n while True:\n m = pt.search(haystack, fz)\n if m:\n index = m.groups()[1][1]-1\n incidence += 1\n haystack = haystack[:index]\n else:\n break\n return incidence","def levenshtein(w1, w2):\n\n if len(w1) < len(w2):\n # check if length of word1 is smaller than word2.\n # if so, call function and switch parameters\n return levenshtein(w2, w1)\n elif len(w1) == 0:\n # if the length of word1 equals 0, that means that\n # the Lev' distance is the length of word2\n return len(w2)\n elif len(w2) == 0:\n # if the length of word2 equals 0, that means that\n # the Lev' distance is the length of word1\n return len(w1)\n elif w1 == w2:\n # check if words are simply the same\n return 0\n\n # thanks to the check above, we can assume that w2 is the longest word\n # we use this information to determine the range of 'previous'\n previous = range(len(w2) + 1)\n\n # iterate over the characters of the first word\n for a, char1 in enumerate(w1):\n current = [a + 1]\n # iterate over the characters of the second word\n for b, char2 in enumerate(w2):\n inserts = previous[b + 1] + 1\n deletions = current[b] + 1\n subs = previous[b] + (char1 != char2)\n current.append(min(inserts, deletions, subs))\n previous = current\n return previous[-1]","def distance(str1, str2):\n return levenshtein.normalized_distance(str1, str2)","def levenshteinDistance(s1, s2):\n singleLetterMapping = {DOWNLEFT: '1', DOWN:'2', DOWNRIGHT:'3',\n LEFT:'4', RIGHT:'6',\n UPLEFT:'7', UP:'8', UPRIGHT:'9'}\n\n len1 = len([singleLetterMapping[letter] for letter in s1])\n len2 = len([singleLetterMapping[letter] for letter in s2])\n\n matrix = list(range(len1 + 1)) * (len2 + 1)\n for i in range(len2 + 1):\n matrix[i] = list(range(i, i + len1 + 1))\n for i in range(len2):\n for j in range(len1):\n if s1[j] == s2[i]:\n matrix[i+1][j+1] = min(matrix[i+1][j] + 1, matrix[i][j+1] + 1, matrix[i][j])\n else:\n matrix[i+1][j+1] = min(matrix[i+1][j] + 1, matrix[i][j+1] + 1, matrix[i][j] + 1)\n return matrix[len2][len1]","def damerau_levenshtein_similarity(s1, s2):\n max_cost = max(len(s1), len(s2))\n\n if max_cost == 0:\n return 1.0\n\n return 1.0 - float(damerau_levenshtein_distance(s1, s2)) / max_cost","def kmp_strstr(haystack, needle):\r\n def computeLPSArray(word):\r\n # The explaination of this function is in _LPSArray()\r\n lps = [0] * len(word)\r\n wordIdx = 0\r\n delta = 1\r\n while delta < len(word):\r\n while delta < len(word) and word[delta] == word[wordIdx]:\r\n lps[delta] = wordIdx + 1\r\n wordIdx += 1\r\n delta += 1\r\n if wordIdx != 0:\r\n wordIdx = lps[wordIdx-1]\r\n else:\r\n delta += 1\r\n return lps\r\n\r\n # handle special cases\r\n if haystack == needle:\r\n return [0]\r\n elif not needle:\r\n return [0]\r\n elif not haystack:\r\n return []\r\n # init lps table\r\n lps = computeLPSArray(needle)\r\n ans = []\r\n # main loop\r\n i_haystack = 0\r\n i_needle = 0\r\n while i_haystack < len(haystack):\r\n if haystack[i_haystack] == needle[i_needle]:\r\n i_haystack += 1\r\n i_needle += 1\r\n # print i_needle, i_haystack\r\n if i_needle == len(needle):\r\n ans.append(i_haystack - i_needle)\r\n i_needle = lps[i_needle-1]\r\n elif i_needle != 0:\r\n i_needle = lps[i_needle-1]\r\n else:\r\n i_haystack += 1\r\n\r\n return ans","def levenshtein(proposed, gold, normalize=False):\n lev_densities = []\n for x, y in zip(proposed, gold):\n score = editdistance.eval(x, y)\n if normalize:\n score /= len(y)\n lev_densities.append(score)\n return sum(lev_densities) / len(lev_densities)","def get_best_match(query, corpus, step=4, flex=3, case_sensitive=False, verbose=False):\n\n def _match(a, b):\n \"\"\"Compact alias for SequenceMatcher.\"\"\"\n return SequenceMatcher(None, a, b).ratio()\n\n def scan_corpus(step):\n \"\"\"Return list of match values from corpus-wide scan.\"\"\"\n match_values = []\n\n m = 0\n while m + qlen - step <= len(corpus):\n match_values.append(_match(query, corpus[m : m-1+qlen]))\n if verbose:\n print(query, \"-\", corpus[m: m + qlen], _match(query, corpus[m: m + qlen]))\n m += step\n\n return match_values\n\n def index_max(v):\n \"\"\"Return index of max value.\"\"\"\n return max(range(len(v)), key=v.__getitem__)\n\n def adjust_left_right_positions():\n \"\"\"Return left/right positions for best string match.\"\"\"\n # bp_* is synonym for 'Best Position Left/Right' and are adjusted \n # to optimize bmv_*\n p_l, bp_l = [pos] * 2\n p_r, bp_r = [pos + qlen] * 2\n\n # bmv_* are declared here in case they are untouched in optimization\n bmv_l = match_values[p_l / step]\n bmv_r = match_values[p_l / step]\n\n for f in range(flex):\n ll = _match(query, corpus[p_l - f: p_r])\n if ll > bmv_l:\n bmv_l = ll\n bp_l = p_l - f\n\n lr = _match(query, corpus[p_l + f: p_r])\n if lr > bmv_l:\n bmv_l = lr\n bp_l = p_l + f\n\n rl = _match(query, corpus[p_l: p_r - f])\n if rl > bmv_r:\n bmv_r = rl\n bp_r = p_r - f\n\n rr = _match(query, corpus[p_l: p_r + f])\n if rr > bmv_r:\n bmv_r = rr\n bp_r = p_r + f\n\n if verbose:\n print(\"\\n\" + str(f))\n print(\"ll: -- value: %f -- snippet: %s\" % (ll, corpus[p_l - f: p_r]))\n print(\"lr: -- value: %f -- snippet: %s\" % (lr, corpus[p_l + f: p_r]))\n print(\"rl: -- value: %f -- snippet: %s\" % (rl, corpus[p_l: p_r - f]))\n print(\"rr: -- value: %f -- snippet: %s\" % (rl, corpus[p_l: p_r + f]))\n\n return bp_l, bp_r, _match(query, corpus[bp_l : bp_r])\n\n if not case_sensitive:\n query = query.lower()\n corpus = corpus.lower()\n\n qlen = len(query)\n\n if flex >= qlen/2:\n print(\"Warning: flex exceeds length of query / 2. Setting to default.\")\n flex = 3\n\n match_values = scan_corpus(step)\n pos = index_max(match_values) * step\n\n pos_left, pos_right, match_value = adjust_left_right_positions()\n\n return corpus[pos_left: pos_right].strip(), match_value","def lev_dist(s1, s2):\n\n if s1 is None or s2 is None:\n return np.NaN\n if pd.isnull(s1) or pd.isnull(s2):\n return np.NaN\n\n # Create the similarity measure object\n measure = sm.Levenshtein()\n\n s1 = gh.convert_to_str_unicode(s1)\n s2 = gh.convert_to_str_unicode(s2)\n\n # Call the function to compute the distance measure.\n return measure.get_raw_score(s1, s2)","def iterative_levenshtein(s, t):\n rows = len(s)+1\n cols = len(t)+1\n dist = [[0 for x in range(cols)] for x in range(rows)]\n # source prefixes can be transformed into empty strings \n # by deletions:\n for i in range(1, rows):\n dist[i][0] = i\n # target prefixes can be created from an empty source string\n # by inserting the characters\n for i in range(1, cols):\n dist[0][i] = i\n \n for col in range(1, cols):\n for row in range(1, rows):\n if s[row-1] == t[col-1]:\n cost = 0\n else:\n cost = 1\n dist[row][col] = min(dist[row-1][col] + 1, # deletion\n dist[row][col-1] + 1, # insertion\n dist[row-1][col-1] + cost) # substitution\n #for r in range(rows):\n #print(dist[r])\n \n \n return dist[row][col]","def edit_distance(str1, str2, reconstruct_answer=False, method=alignments.Levinshtein(),\n swap_case_on_mismatch=True):\n method = alignments.Levinshtein() if method is None else method\n return align(str1, str2, reconstruct_answer, method, swap_case_on_mismatch)","def levenshtein_distance(first, second):\n if len(first) > len(second):\n first, second = second, first\n if len(second) == 0:\n return len(first)\n first_length = len(first) + 1\n second_length = len(second) + 1\n distance_matrix = [range(second_length) for x in range(first_length)]\n for i in range(1, first_length):\n for j in range(1, second_length):\n deletion = distance_matrix[i-1][j] + 1\n insertion = distance_matrix[i][j-1] + 1\n substitution = distance_matrix[i-1][j-1]\n if first[i-1] != second[j-1]:\n substitution += 1\n distance_matrix[i][j] = min(insertion, deletion, substitution)\n\n return distance_matrix[first_length-1][second_length-1]","def levenshtein(seq1: str, seq2: str) -> int:\n if seq1 == \"\":\n return len(seq2)\n if seq2 == \"\":\n return len(seq1)\n if seq1[-1] == seq2[-1]:\n cost = 0\n else:\n cost = 1\n \n result = min([levenshtein(seq1[:-1], seq2) + 1,\n levenshtein(seq1, seq2[:-1]) + 1,\n levenshtein(seq1[:-1], seq2[:-1]) + cost ])\n return result","def _levenshtein_distance(t1: Trace, t2: Trace):\n if t1.length > t2.length:\n t1, t2 = t2, t1\n\n distances = range(t1.length + 1)\n for i2, c2 in enumerate(t2.event_list):\n distances_ = [i2 + 1]\n for i1, c1 in enumerate(t1.event_list):\n if c1 == c2:\n distances_.append(distances[i1])\n else:\n distances_.append(1 + min((distances[i1], distances[i1 + 1], distances_[-1])))\n distances = distances_\n return distances[-1]","def Levenshtein(a, b):\n v0 = list(range(len(b)+1))\n v1 = list(range(len(b)+1)) # Or whatever.\n\n for i in range(len(a)):\n v1[0] = i + 1\n\n for j in range(len(b)):\n deletionCost = v0[j + 1] + 1\n insertionCost = v1[j] + 1\n substitutionCost = v0[j] if a[i] == b[j] else v0[j]+1\n v1[j + 1] = min(deletionCost, insertionCost, substitutionCost)\n\n v1, v0 = v0, v1\n return v0[len(b)]","def damerau_levenshtein_distance(s1, s2):\n\n utils.check_for_none(s1, s2)\n utils.check_for_type(str, s1, s2)\n\n # s1 = utils.unicode_normalize(s1)\n # s2 = utils.unicode_normalize(s2)\n\n n1, n2 = len(s1), len(s2)\n infinite = n1 + n2\n\n char_arr = defaultdict(int)\n dp = [[0] * (n2 + 2) for _ in range(n1 + 2)]\n\n dp[0][0] = infinite\n for i in range(0, n1 + 1):\n dp[i + 1][0] = infinite\n dp[i + 1][1] = i\n for i in range(0, n2 + 1):\n dp[0][i + 1] = infinite\n dp[1][i + 1] = i\n\n for i in range(1, n1 + 1):\n db = 0\n for j in range(1, n2 + 1):\n i1 = char_arr[s2[j - 1]]\n j1 = db\n cost = 1\n if s1[i - 1] == s2[j - 1]:\n cost = 0\n db = j\n\n dp[i + 1][j + 1] = min(dp[i][j] + cost,\n dp[i + 1][j] + 1,\n dp[i][j + 1] + 1,\n dp[i1][j1] + (i - i1 - 1) + 1 + (j - j1 - 1))\n char_arr[s1[i - 1]] = i\n\n return dp[n1 + 1][n2 + 1]","def get_fuzzy_match(object, answer, threshold=80):\n answer_phrase = generate_ngrams(answer)\n if answer_phrase:\n best_match = [fuzz.ratio(object, phr) for phr in answer_phrase]\n if np.max(best_match)>threshold:\n return np.max(best_match), answer_phrase[np.argmax(best_match)]\n else:\n return 0,''\n else:\n return 0, ''","def test_string_similarity_constraint():\n f = SimilarityConstraint(func=LevenshteinDistance(), pred=GreaterThan(0.5))\n assert f('BROOKLYN', 'BROKLYN')\n assert not f('BROOKLYN', 'QUEENS')","def fuzzy_match(replist, wordset):\n matches = []\n for rep in replist:\n for word in wordset:\n matches.append((Levenshtein.distance(str(rep), word), word, rep))\n\n matches.sort(key=lambda x: (x[0], x[2].weight))\n try:\n return str(matches[0][2]), matches[0][1]\n except IndexError:\n return (\"\", \"\")","def iterative_levenshtein(self, w1, d1, w2, d2):\n rows = len(w1) + 1\n cols = len(w2) + 1\n dist = [[0 for x in range(cols)] for x in range(rows)]\n # source prefixes can be transformed into empty strings\n # by deletions:\n for i in range(1, rows):\n dist[i][0] = i\n # target prefixes can be created from an empty source string\n # by inserting the characters\n for i in range(1, cols):\n dist[0][i] = i\n\n for col in range(1, cols):\n for row in range(1, rows):\n if w1[row - 1] == w2[col - 1]:\n cost = 0\n else:\n cost = 1\n dist[row][col] = min(dist[row - 1][col] + 1, # deletion\n dist[row][col - 1] + 1, # insertion\n dist[row - 1][col - 1] + cost) # substitution\n return dist[row][col] < 5","def similarity(a, b):\n distance = Levenshtein.distance(a, b)\n return 1 - (distance / max((len(a), len(b))))","def dameraulevenshtein(seq1, seq2):\n # codesnippet:D0DE4716-B6E6-4161-9219-2903BF8F547F\n # Conceptually, this is based on a len(seq1) + 1 * len(seq2) + 1 matrix.\n # However, only the current and two previous rows are needed at once,\n # so we only store those.\n oneago = None\n thisrow = list(range(1, len(seq2) + 1)) + [0]\n for x in range(len(seq1)):\n # Python lists wrap around for negative indices, so put the\n # leftmost column at the *end* of the list. This matches with\n # the zero-indexed strings and saves extra calculation.\n twoago, oneago, thisrow = (oneago, thisrow, [0] * len(seq2) + [x + 1])\n for y in range(len(seq2)):\n delcost = oneago[y] + 1\n addcost = thisrow[y - 1] + 1\n subcost = oneago[y - 1] + (seq1[x] != seq2[y])\n thisrow[y] = min(delcost, addcost, subcost)\n # This block deals with transpositions\n if (x > 0 and y > 0 and seq1[x] == seq2[y - 1]\n and seq1[x - 1] == seq2[y] and seq1[x] != seq2[y]):\n thisrow[y] = min(thisrow[y], twoago[y - 2] + 1)\n return thisrow[len(seq2) - 1]","def dameraulevenshtein(seq1, seq2):\n # codesnippet:D0DE4716-B6E6-4161-9219-2903BF8F547F\n # Conceptually, this is based on a len(seq1) + 1 * len(seq2) + 1 matrix.\n # However, only the current and two previous rows are needed at once,\n # so we only store those.\n oneago = None\n thisrow = list(range(1, len(seq2) + 1)) + [0]\n for x in range(len(seq1)):\n # Python lists wrap around for negative indices, so put the\n # leftmost column at the *end* of the list. This matches with\n # the zero-indexed strings and saves extra calculation.\n twoago, oneago, thisrow = (oneago, thisrow, [0] * len(seq2) + [x + 1])\n for y in range(len(seq2)):\n delcost = oneago[y] + 1\n addcost = thisrow[y - 1] + 1\n subcost = oneago[y - 1] + (seq1[x] != seq2[y])\n thisrow[y] = min(delcost, addcost, subcost)\n # This block deals with transpositions\n if (x > 0 and y > 0 and seq1[x] == seq2[y - 1]\n and seq1[x - 1] == seq2[y] and seq1[x] != seq2[y]):\n thisrow[y] = min(thisrow[y], twoago[y - 2] + 1)\n return thisrow[len(seq2) - 1]","def levenshtein_similarity(self, top, rows):\n if len(rows) > 1:\n return (\n [(1 - editdistance.eval(top, rows[i]) / max(len(top), len(rows[i]))) for i in\n range(0, len(rows))])\n else:\n return 1","def dameraulevenshtein(seq1, seq2):\n # Conceptually, this is based on a len(seq1) + 1 * len(seq2) + 1 matrix.\n # However, only the current and two previous rows are needed at once,\n # so we only store those.\n oneago = None\n thisrow = list(range(1, len(seq2) + 1)) + [0]\n for x in range(len(seq1)):\n # Python lists wrap around for negative indices, so put the\n # leftmost column at the *end* of the list. This matches with\n # the zero-indexed strings and saves extra calculation.\n twoago, oneago, thisrow = oneago, thisrow, [0] * len(seq2) + [x + 1]\n for y in range(len(seq2)):\n delcost = oneago[y] + 1\n addcost = thisrow[y - 1] + 1\n subcost = oneago[y - 1] + (seq1[x] != seq2[y])\n thisrow[y] = min(delcost, addcost, subcost)\n # This block deals with transpositions\n if (x > 0 and y > 0 and seq1[x] == seq2[y - 1]\n and seq1[x-1] == seq2[y] and seq1[x] != seq2[y]):\n thisrow[y] = min(thisrow[y], twoago[y - 2] + 1)\n return thisrow[len(seq2) - 1]","def levenshtein(source, target):\n if len(source) < len(target):\n return levenshtein(target, source)\n\n # So now we have len(source) >= len(target).\n if len(target) == 0:\n return len(source)\n\n # We call tuple() to force strings to be used as sequences\n # ('c', 'a', 't', 's') - numpy uses them as values by default.\n source = np.array(tuple(source))\n target = np.array(tuple(target))\n\n # We use a dynamic programming algorithm, but with the\n # added optimization that we only need the last two rows\n # of the matrix.\n previous_row = np.arange(target.size + 1)\n for s in source:\n # Insertion (target grows longer than source):\n current_row = previous_row + 1\n\n # Substitution or matching:\n # Target and source items are aligned, and either\n # are different (cost of 1), or are the same (cost of 0).\n current_row[1:] = np.minimum(\n current_row[1:],\n np.add(previous_row[:-1], target != s))\n\n # Deletion (target grows shorter than source):\n current_row[1:] = np.minimum(\n current_row[1:],\n current_row[0:-1] + 1)\n\n previous_row = current_row\n\n return previous_row[-1]","def spell_checker(input_string, lexical_tree=0, transform_list_in=[], transform_list_out=[], templates=[]):\n dict = read_file('dict.txt').split()\n word_list = list(set(re.split('\\W', input_string)))\n word_list = [i for i in word_list if len(i) > 0]\n print templates\n levenshtein_distance_obj = levenshtein_distance.LevenshteinDistance(\n templates=dict if templates == [] else templates, string_or_list=0)\n print levenshtein_distance_obj.templates\n for word in word_list:\n right_word = levenshtein_distance_obj.levenshtein_distance(input_string=word, strategy=0, string_or_list=0,\n case_sensitive=0, lexical_tree=lexical_tree,\n transform_list_in=transform_list_in,\n transform_list_out=transform_list_out)[1].lower()\n input_string = re.sub('(\\W)' + word + '(\\W)', '\\g<1>' + right_word[1:] + '\\g<2>', input_string)\n print right_word\n return input_string","def __levenshtein(a, b):\n\n n, m = len(a), len(b)\n if n > m:\n # Make sure n <= m, to use O(min(n,m)) space\n a, b = b, a\n n, m = m, n\n\n current = list(range(n + 1))\n for i in range(1, m + 1):\n previous, current = current, [i] + [0] * n\n for j in range(1, n + 1):\n add, delete = previous[j] + 1, current[j - 1] + 1\n change = previous[j - 1]\n if a[j - 1] != b[i - 1]:\n change = change + 1\n current[j] = min(add, delete, change)\n\n return current[n]","def fuzzy_match(pattern, instring, adj_bonus=5, sep_bonus=10, camel_bonus=10,\n lead_penalty=-3, max_lead_penalty=-9, unmatched_penalty=-1):\n score, p_idx, s_idx, p_len, s_len = 0, 0, 0, len(pattern), len(instring)\n prev_match, prev_lower = False, False\n prev_sep = True # so that matching first letter gets sep_bonus\n best_letter, best_lower, best_letter_idx = None, None, None\n best_letter_score = 0\n matched_indices = []\n\n while s_idx != s_len:\n p_char = pattern[p_idx] if (p_idx != p_len) else None\n s_char = instring[s_idx]\n p_lower = p_char.lower() if p_char else None\n s_lower, s_upper = s_char.lower(), s_char.upper()\n\n next_match = p_char and p_lower == s_lower\n rematch = best_letter and best_lower == s_lower\n\n advanced = next_match and best_letter\n p_repeat = best_letter and p_char and best_lower == p_lower\n\n if advanced or p_repeat:\n score += best_letter_score\n matched_indices.append(best_letter_idx)\n best_letter, best_lower, best_letter_idx = None, None, None\n best_letter_score = 0\n\n if next_match or rematch:\n new_score = 0\n\n # apply penalty for each letter before the first match\n # using max because penalties are negative (so max = smallest)\n if p_idx == 0:\n score += max(s_idx * lead_penalty, max_lead_penalty)\n\n # apply bonus for consecutive matches\n if prev_match:\n new_score += adj_bonus\n\n # apply bonus for matches after a separator\n if prev_sep:\n new_score += sep_bonus\n\n # apply bonus across camelCase boundaries\n if prev_lower and s_char == s_upper and s_lower != s_upper:\n new_score += camel_bonus\n\n # update pattern index iff the next pattern letter was matched\n if next_match:\n p_idx += 1\n\n # update best letter match (may be next or rematch)\n if new_score >= best_letter_score:\n # apply penalty for now-skipped letter\n if best_letter is not None:\n score += unmatched_penalty\n best_letter = s_char\n best_lower = best_letter.lower()\n best_letter_idx = s_idx\n best_letter_score = new_score\n\n prev_match = True\n\n else:\n score += unmatched_penalty\n prev_match = False\n\n prev_lower = s_char == s_lower and s_lower != s_upper\n prev_sep = s_char in '_ '\n\n s_idx += 1\n\n if best_letter:\n score += best_letter_score\n matched_indices.append(best_letter_idx)\n\n return p_idx == p_len, score","def needleMatching(self):\n #productive\n profprint()\n modelNodes=slicer.mrmlScene.GetNodesByClass('vtkMRMLModelNode')\n nbNode=modelNodes.GetNumberOfItems()\n result=[]\n found=[]\n #print nbNode\n for nthNode in range(nbNode):\n node=slicer.mrmlScene.GetNthNodeByClass(nthNode,'vtkMRMLModelNode')\n if node.GetID() not in found and node.GetAttribute('type')!='Validation':\n dist=[]\n polydata = node.GetPolyData()\n if polydata!=None:\n bounds = polydata.GetBounds()\n for nthNode2 in range(nbNode):\n node2=slicer.mrmlScene.GetNthNodeByClass(nthNode2,'vtkMRMLModelNode')\n if node2.GetID() not in found and node2.GetAttribute('type')=='Validation':\n polydata2 = node2.GetPolyData()\n if polydata2!=None and polydata2.GetNumberOfPoints()>100 and polydata.GetNumberOfPoints()>100:\n\n axialDistance=self.distTip( int(node.GetID().strip('vtkMRMLModelNode')) , int(node2.GetID().strip('vtkMRMLModelNode')))\n \n dist.append([axialDistance,node2.GetID()])\n # print axialDistance\n \n if dist!=[]:\n match=[min(dist)[0],min(dist)[1],node.GetID()]\n result.append(match)\n found.append(min(dist)[1])\n found.append(node.GetID()) \n node.GetDisplayNode().SetSliceIntersectionVisibility(1)\n # print result\n return result","def scientific_match_ratio(str1, str2, keywords):\n\n # Get rid of the numbers\n str1_numberless = remove_numbers(str1)\n str2_numberless = remove_numbers(str2)\n\n # Get the keywords and whatever remains after removing the keywords\n str1_keywords, str1_remainder = get_common_words_in_description(str1_numberless, keywords)\n str2_keywords, str2_remainder = get_common_words_in_description(str2_numberless, keywords)\n\n remainder_dist = string_num_matches(str1_remainder, str2_remainder)\n common_keywords = str1_keywords.intersection(str2_keywords)\n\n common_keyword_total_len = 0\n for common_kword in common_keywords:\n common_keyword_total_len += len(common_kword)\n\n return (remainder_dist + common_keyword_total_len) * 1.0 / max(len(str1_numberless), len(str2_numberless))","def levenshtein_distance(s, t, alphabet=string.printable, **weight_dict):\n if len(s) == 0 or len(t) == 0:\n return max([len(s), len(t)])\n\n rows = len(s) + 1\n cols = len(t) + 1\n\n w = dict((x, (1, 1, 1)) for x in alphabet + alphabet.upper())\n if weight_dict:\n w.update(weight_dict)\n\n dist = [[0 for _ in range(cols)] for _ in range(rows)]\n # source prefixes can be transformed into empty strings\n # by deletions:\n for row in range(1, rows):\n dist[row][0] = dist[row - 1][0] + w[s[row - 1]][0]\n # target prefixes can be created from an empty source string\n # by inserting the characters\n for col in range(1, cols):\n dist[0][col] = dist[0][col - 1] + w[t[col - 1]][1]\n\n for col in range(1, cols):\n for row in range(1, rows):\n deletes = w[s[row - 1]][0]\n inserts = w[t[col - 1]][1]\n subs = max((w[s[row - 1]][2], w[t[col - 1]][2]))\n if s[row - 1] == t[col - 1]:\n subs = 0\n else:\n subs = subs\n dist[row][col] = min(\n dist[row - 1][col] + deletes,\n dist[row][col - 1] + inserts,\n dist[row - 1][col - 1] + subs,\n ) # substitution\n\n return dist[row][col]","def match_words_to_search(chunks, searchresult, compare_func, join=True):\n wordlist = [hebstrip(w)[1] for w in word_bound.split(searchresult)]\n wordset = set(wordlist)\n genlist = [\n m\n for m in [\n match_one(rlist, wordset)\n for rlist in chunks.linked_heb\n if rlist.data\n ]\n if m\n ]\n ours = [i[0] for i in genlist]\n theirs = [i[1] for i in genlist]\n if join:\n return compare_func(\" \".join(ours), \" \".join(wordlist)), theirs\n else:\n return compare_func(ours, wordlist), theirs","def needleMatching(self):\r\n # productive\r\n profprint()\r\n modelNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLModelNode')\r\n nbNode = modelNodes.GetNumberOfItems()\r\n result = []\r\n found = []\r\n # print nbNode\r\n for nthNode in range(nbNode):\r\n node = slicer.mrmlScene.GetNthNodeByClass(nthNode, 'vtkMRMLModelNode')\r\n if node.GetID() not in found and node.GetAttribute('type') != 'Validation':\r\n dist = []\r\n polydata = node.GetPolyData()\r\n if polydata != None:\r\n bounds = polydata.GetBounds()\r\n for nthNode2 in range(nbNode):\r\n node2 = slicer.mrmlScene.GetNthNodeByClass(nthNode2, 'vtkMRMLModelNode')\r\n if node2.GetID() not in found and node2.GetAttribute('type') == 'Validation':\r\n polydata2 = node2.GetPolyData()\r\n if polydata2 != None and polydata2.GetNumberOfPoints() > 100 and polydata.GetNumberOfPoints() > 100:\r\n tipDistance = self.distTip(int(node.GetID().strip('vtkMRMLModelNode')) , int(node2.GetID().strip('vtkMRMLModelNode')))\r\n baseDistance = self.distBase(int(node.GetID().strip('vtkMRMLModelNode')) , int(node2.GetID().strip('vtkMRMLModelNode')))\r\n name = node.GetName()\r\n manualName = name.lstrip('auto-seg_').lstrip('manual-seg_').lstrip('obturator-seg_').lstrip('0123456789').lstrip('-ID-vtkMRMLModelNode').lstrip('0123456789-')\r\n if manualName==node2.GetName(): dist.append([tipDistance, node2.GetID(), node2.GetName()])\r\n # print tipDistance\r\n if dist != []:\r\n match = [min(dist)[0], min(dist)[1], node.GetID(), min(dist)[2]]\r\n result.append(match)\r\n found.append(min(dist)[1])\r\n found.append(node.GetID())\r\n node.GetDisplayNode().SetSliceIntersectionVisibility(1)\r\n # print result\r\n return result","def get_levenshtein_distance(a, b):\r\n n, m = len(a), len(b)\r\n if n > m:\r\n # Make sure n <= m, to use O(min(n,m)) space\r\n a, b = b, a\r\n n, m = m, n\r\n current_row = range(n+1) # Keep current and previous row, not entire matrix\r\n\r\n for i in range(1, m+1):\r\n previous_row, current_row = current_row, [i]+[0]*n\r\n for j in range(1, n+1):\r\n add, delete, change = previous_row[j]+1, current_row[j-1]+1, previous_row[j-1]\r\n if a[j-1] != b[i-1]:\r\n change += 1\r\n current_row[j] = min(add, delete, change)\r\n return current_row[n]","def levenshtein_dist(s1, s2, dele, add, sub):\n m = np.zeros((len(s1)+1, len(s2)+1), dtype=np.int)\n p = np.zeros((len(s1)+1, len(s2)+1), dtype=np.float)\n for i in range(len(s1)+1):\n m[i, 0] = i\n # compute probability for deletion\n if i == 0:\n p[i, 0] = 1\n else:\n ind = alphabet.index('@')\n p[i, 0] = p[i-1, 0] * dele[ind, alphabet.index(s1[i-1])]\n for j in range(len(s2)+1):\n # compute probability for insertion\n if j == 0:\n p[0, j] = 1\n else:\n prev_char = '@' if j == 1 else s2[j-2]\n p[0, j] = p[0, j-1] * add[alphabet.index(prev_char),\n alphabet.index(s2[j-1])]\n m[0, j] = j\n for i in range(1, 1+len(s1)):\n for j in range(1, len(s2)+1):\n if s1[i-1] == s2[j-1]:\n k = np.argmin([m[i-1, j] + 1, m[i, j-1] + 1, m[i-1, j-1]])\n if k == 0:\n # deletion\n m[i, j] = m[i-1, j] + 1\n prev_char = '@' if j == 1 else s2[j-2]\n p[i, j] = p[i-1, j] * dele[alphabet.index(prev_char), alphabet.index(s1[i-1])]\n elif k == 1:\n # insertion\n m[i, j] = m[i, j-1] + 1\n prev_char = '@' if j == 1 else s2[j-2]\n p[i, j] = p[i, j-1] * add[alphabet.index(prev_char), alphabet.index(s2[j-1])]\n else:\n # no mistake\n m[i, j] = m[i-1, j-1]\n p[i, j] = p[i-1, j-1]\n else:\n k = np.argmin([m[i-1, j] + 1, m[i, j-1] + 1, m[i-1, j-1] + 1])\n if k == 0:\n # deletion\n m[i, j] = m[i-1, j] + 1\n prev_char = '@' if j == 1 else s2[j-2]\n p[i, j] = p[i-1, j] * dele[alphabet.index(prev_char), alphabet.index(s1[i-1])]\n elif k == 1:\n # insertion\n m[i, j] = m[i, j-1] + 1\n prev_char = '@' if j == 1 else s2[j-2]\n p[i, j] = p[i, j-1] * add[alphabet.index(prev_char), alphabet.index(s2[j-1])]\n else:\n # substitution\n m[i, j] = m[i-1, j-1] + 1\n p[i, j] = p[i-1, j-1] * sub[alphabet.index(s1[i-1]), alphabet.index(s2[j-1])]\n # recall that in sub[X, Y], Y is the correct word\n\n return m[len(s1), len(s2)], p[len(s1), len(s2)]","def replace_by_lev(word):\n minimum_lev = -1\n maximum_jac = 0.0\n results = {}\n\n it = iter(postings)\n term = next(it)\n\n while True:\n try:\n if args.jaccard:\n jac = jaccard(set(ngrams(word, 3)), set(ngrams(term, 3)))\n # print(\"JAC => \" + str(jac))\n if jac > maximum_jac:\n maximum_jac = jac\n # print(\"TERM\\t\" + term)\n # print(\"JAC\\t\" + str(jac))\n lev = levenshtein(word, term)\n postings_length = len(postings[term])\n if lev <= minimum_lev or minimum_lev == -1: # and (postings_length > occurrences):\n minimum_lev = lev\n results.update({term: (minimum_lev, postings_length)})\n term = next(it)\n else:\n term = next(it)\n\n else:\n lev = levenshtein(word, term)\n postings_length = len(postings[term])\n if lev <= minimum_lev or minimum_lev == -1: # and (postings_length > occurrences):\n # print(\"MIN => \" + str(minimum_lev))\n minimum_lev = lev\n results.update({term: (minimum_lev, postings_length)})\n term = next(it)\n else:\n term = next(it)\n except StopIteration:\n # print(results)\n return results","def ApproxStrMatch(pattern, text, d, debug = False):\n\tcount = 0\n\tindex = []\n\tfor i in range(len(text)-len(pattern)+1):\n\t\tif debug:\n\t\t\tprint text[i:i+len(pattern)]\n\t\t\tprint HammingDist(text[i:i+len(pattern)], pattern)\n\t\tif HammingDist(text[i:i+len(pattern)], pattern) <= d:\n\t\t\tcount += 1\n\t\t\tindex.append(i)\n\treturn index","def dameraulevenshtein(self, seq1, seq2):\n # codesnippet:D0DE4716-B6E6-4161-9219-2903BF8F547F\n # Conceptually, this is based on a len(seq1) + 1 * len(seq2) + 1 matrix.\n # However, only the current and two previous rows are needed at once,\n # so we only store those.\n oneago = None\n thisrow = range(1, len(seq2) + 1) + [0]\n for x in xrange(len(seq1)):\n # Python lists wrap around for negative indices, so put the\n # leftmost column at the *end* of the list. This matches with\n # the zero-indexed strings and saves extra calculation.\n twoago, oneago, thisrow = oneago, thisrow, [0] * len(seq2) + [x + 1]\n for y in xrange(len(seq2)):\n delcost = oneago[y] + 1\n addcost = thisrow[y - 1] + 1\n subcost = oneago[y - 1] + (seq1[x] != seq2[y])\n thisrow[y] = min(delcost, addcost, subcost)\n # This block deals with transpositions\n if (x > 0 and y > 0 and seq1[x] == seq2[y - 1]\n and seq1[x-1] == seq2[y] and seq1[x] != seq2[y]):\n thisrow[y] = min(thisrow[y], twoago[y - 2] + 1)\n return thisrow[len(seq2) - 1]","def levenshteinDistance(s, t, asRatioOfMax = False):\n\n if s == None:\n s = \"\"\n if t == None:\n t = \"\"\n\n if t == s:\n return 0\n if len(s) == 0:\n return len(t)\n if len(t) == 0:\n return len(s)\n\n v0 = [x for x in range(len(t)+1)]\n v1 = [0 for x in range(len(t)+1)]\n\n for i, si in enumerate(s):\n\n v1[0] = i + 1\n\n for j, tj in enumerate(t):\n\n if si == tj:\n cost = 0\n else:\n cost = 1\n\n j1 = v1[j] + 1\n j2 = v0[j + 1] + 1\n j3 = v0[j] + cost\n \n if j1 < j2 and j1 < j3:\n v1[j + 1] = j1\n continue\n \n if j2 < j3:\n v1[j+1] = j2\n else:\n v1[j+1] = j3\n \n v0 = v1.copy()\n\n if not asRatioOfMax:\n return v1[len(t)]\n\n return 1 - v1[len(t)]/max([len(t), len(s)])","def leveinshtein_distance(source,target):\r\n\t#Step 1\r\n\ts_len=len(source)\r\n\tt_len=len(target)\r\n\tcost=0\r\n\tif(s_len==0):\r\n\t\treturn t_len\r\n\tif(t_len==0):\r\n\t\treturn s_len\r\n\tprint(\"Dimensions:\\n\\tN:%d\\n\\tM:%d\"%(s_len,t_len))\r\n\t#Step 2\r\n\tmatrix=[[0 for _ in range(0,t_len+1)] for _ in range(0, s_len+1)]\r\n\t#Initialize first row 0..s_len\r\n\tfor idx in range(0,s_len+1):\r\n\t\tmatrix[idx][0]=idx\r\n\t#Initialize the first column 0..t_len\r\n\tfor idx in range(0, t_len+1):\r\n\t\tmatrix[0][idx]=idx\r\n\tprint(\"===Original===\")\r\n\tprint_matrix(matrix,source,target)\r\n\t#Step 3\r\n\tfor i in range(1,s_len+1):\r\n\t\tch=source[i-1]\r\n\t\t#print(ch)\r\n\t\t#Step 4\r\n\t\tfor j in range(1,t_len+1):\r\n\t\t\t#print(\">%s\"%target[j-1])\r\n\t\t\t#Step 5\r\n\t\t\tif ch==target[j-1]:\r\n\t\t\t\tcost=0\r\n\t\t\telse:\r\n\t\t\t\tcost=1\r\n\t\t\t#Step 6\r\n\t\t\t\r\n\t\t\t#print(\"(i,j)=>(%d,%d)\"%(i,j))\r\n\t\t\t#print(matrix[i][j])\r\n\t\t\tmatrix[i][j]=minimum(\r\n\t\t\t\tmatrix[i-1][j]+1,\r\n\t\t\t\tmatrix[i][j-1]+1,\r\n\t\t\t\tmatrix[i-1][j-1]+cost\r\n\t\t\t)\r\n\tprint(\"===Final Matrix===\")\r\n\tprint_matrix(matrix,source,target)\r\n\treturn matrix[s_len-1][t_len-1]","def matcher(features1, features2):\n #TODO: write a matching function\n #Performing the L2-Norm\n new_features1=[]\n new_features2=[]\n for itr in range(5):\n [rootOfSquare1,rootOfSquare2] = sumOfSquares(features1[itr],features2[itr])\n new_features1.append(np.array(features1[itr])/rootOfSquare1)\n new_features2.append(np.array(features2[itr])/rootOfSquare2)\n indices = []\n for itr in range(len(new_features1)):\n findMinDist=[]\n #findMaxCosineVal=[]\n for itr2 in range(len(new_features2)):\n f1 = new_features1[itr]\n f2 = new_features2[itr2]\n\n #For evaluating the cosine similarity\n # [rootOfSquare1,rootOfSquare2] = sumOfSquares(f1,f2)\n # numerator = np.array(f1)*np.array(f2)\n # numeratorSum = sum(numerator)\n # denominator = rootOfSquare1*rootOfSquare2\n # cosine = np.divide(numeratorSum,denominator)\n # findMaxCosineVal.append(cosine)\n\n #For evaluating the similarity based on euclidean distance\n Dist = np.array(f1) - np.array(f2)\n sum=0\n for i in Dist:\n sum=sum+math.pow(i,2)\n rootOfSum = math.sqrt(sum)\n findMinDist.append(rootOfSum)\n # print \"itr: \", itr, \" Matching scores: \", findMaxCosineVal\n # bestMatch = findMaxCosineVal.index(max(findMaxCosineVal))\n bestMatch = findMinDist.index(min(findMinDist))\n indices.append([itr,bestMatch])\n return indices","def levenshtein_similarity(s1, s2, insert=None, delete=None, substitute=None,\n insert_default=1, delete_default=1, substitute_default=1,\n lower_bound=None):\n insert = insert if isinstance(insert, dict) else {}\n delete = delete if isinstance(delete, dict) else {}\n substitute = substitute if isinstance(substitute, dict) else {}\n\n def compute_max_cost(s):\n return sum([\n max(\n insert[c] if c in insert else insert_default,\n delete[c] if c in delete else delete_default,\n substitute[c] if c in substitute else substitute_default\n ) for c in s\n ])\n\n def estimate_min_char_cost(s):\n return min([min(\n insert[c] if c in insert else insert_default,\n delete[c] if c in delete else delete_default,\n substitute[c] if c in substitute else substitute_default\n ) for c in s])\n\n utils.check_for_none(s1, s2)\n utils.check_for_type(str, s1, s2)\n\n max_cost = max(compute_max_cost(s1), compute_max_cost(s2))\n\n if lower_bound:\n diff = abs(len(s1) - len(s2))\n if len(s1) == 0 and len(s2) == 0:\n return 1.0\n elif len(s1) == 0:\n min_lev = float(diff * estimate_min_char_cost(s2))\n elif len(s2) == 0:\n min_lev = float(diff * estimate_min_char_cost(s1))\n else:\n min_lev = float(diff * min(estimate_min_char_cost(s1), estimate_min_char_cost(s2)))\n est_sim = 1.0 - min_lev / max_cost\n if est_sim < lower_bound:\n return 0.0\n\n lev = levenshtein_distance(s1, s2, insert, delete, substitute,\n insert_default, delete_default, substitute_default)\n\n if max_cost < lev:\n raise ValueError('Illegal value of operation cost')\n\n if max_cost == 0:\n return 1.0\n\n lev_sim = 1.0 - float(lev) / max_cost\n if lower_bound and lev_sim < lower_bound:\n return 0.0\n return lev_sim","def get_fuzz_ratio(first_word, second_word):\n return fuzz.ratio(first_word, second_word), first_word, second_word","def ratio(n1,n2, explain=0, optimize=False):\n weight_normal_form = 5.0 #distance between soundexes of normal form\n weight_normal_form_soundex = 8.0 #average distance between soundexes of normal form\n weight_geslachtsnaam1 = 10.0 #distance between soundexes of geslachtsnamen\n weight_geslachtsnaam2 = 10.0 #distance between geslachtsnaam\n weight_initials = 2 #distance between initials\n\n nf1 = n1.guess_normal_form()\n nf2 = n2.guess_normal_form()\n\n if not nf1 or not nf2:\n return 0.0\n elif nf1 == nf2:\n return 1.0\n ratio_normal_form = Similarity.average_distance(split(nf1), split(nf2))\n \n #create a simkplified soundex set for this name\n #remove stopwords\n# nf1 = remove_stopwords( nf1)\n# nf2 = remove_stopwords( nf2)\n \n se1 = n1.get_normal_form_soundex()\n se2 = n2.get_normal_form_soundex()\n ratio_normal_form_soundex = Similarity.average_distance( se1, se2)\n \n #gelachtsnaam wordt op twee manieren met elkaar vergeleken\n g1 = n1.geslachtsnaam() #or n1.get_volledige_naam()\n g2 = n2.geslachtsnaam() #or n2.get_volledige_naam()\n g1 = to_ascii(g1)\n g2 = to_ascii(g2)\n if not optimize:\n #de soundexes van de achternaam worden meegewoen\n #g1_soundex = n1.soundex_nl(g1, group=2, length=-1)\n g1_soundex = n1.geslachtsnaam_soundex()\n #g2_soundex = n2.soundex_nl(g2, group=2, length=-1)\n g2_soundex = n2.geslachtsnaam_soundex()\n ratio_geslachtsnaam1 = Similarity.average_distance(g1_soundex, g2_soundex)\n else:\n ratio_geslachtsnaam1 = 1 \n weight_geslachtsnaam1 = 0\n \n #n de afstand van de woorden in de achtenraam zelf\n ratio_geslachtsnaam2 = Similarity.average_distance(\n re.split('[ \\.\\,\\-]', g1.lower()),\n re.split('[ \\.\\,\\-]', g2.lower()),\n levenshtein_ratio)\n n1_initials = n1.initials()\n n1_initials_lower = n1_initials.lower()\n n2_initials = n2.initials()\n n2_initials_lower = n2_initials.lower()\n n1_contains_initials = n1.contains_initials()\n n2_contains_initials = n2.contains_initials()\n #count initials only if we have more than one\n #(or perhaps make this: if we know the first name)\n if len(n1_initials) == 1 or len(n2_initials) == 1:\n #initials count much less if there is only one\n weight_initials = weight_initials_if_one_name_consists_of_one_word_only\n# ratio_initials = .5\n ratio_initials = levenshtein_ratio(n1_initials_lower, n2_initials_lower)\n elif n1_contains_initials or n2_contains_initials:\n ratio_initials = levenshtein_ratio(n1_initials_lower, n2_initials_lower)\n weight_initials = weight_initials_if_one_name_is_in_initials\n elif len(n1_initials) > 1 and len(n2_initials) > 1:\n ratio_initials = levenshtein_ratio(n1_initials_lower, n2_initials_lower)\n else:\n ratio_initials = 0.7\n \n if n1_contains_initials or n2_contains_initials:\n weight_normal_form = weight_normal_form_if_one_name_is_in_initials \n weight_normal_form_soundex = weight_normal_form_soundex_if_one_name_is_in_initials\n\n counter = (ratio_normal_form * weight_normal_form +\n ratio_normal_form_soundex * weight_normal_form_soundex +\n ratio_geslachtsnaam1 * weight_geslachtsnaam1 +\n ratio_geslachtsnaam2 * weight_geslachtsnaam2 +\n ratio_initials * weight_initials)\n numerator = (weight_normal_form + weight_normal_form_soundex +\n weight_initials + weight_geslachtsnaam1 + weight_geslachtsnaam2)\n if numerator == 0:\n return 0.0\n final_ratio = counter/numerator\n\n if explain:\n s = '-' * 100 + '\\n'\n s += 'Naam1: %s [%s] [%s] %s\\n' % (n1, n1_initials, n1.guess_normal_form(), se1)\n s += 'Naam2: %s [%s] [%s] %s\\n' % (n2, n2_initials, n2.guess_normal_form(), se2)\n s += 'Similarity ratio: %s\\n' % final_ratio\n s += '--- REASONS' + '-' * 30 + '\\n'\n format_s = '%-30s | %-10s | %-10s | %-10s | %-10s | %s-10s\\n'\n s += format_s % ('\\t property', ' ratio', ' weight','relative_weight', ' r*w', 'r * relative_w')\n s += '\\t' + '-' * 100 + '\\n'\n format_s = '\\t%-30s | %-10f | %-10f | %-10f | %-10f | %-10f\\n'\n s += format_s % (' normal_form', ratio_normal_form, weight_normal_form,weight_normal_form/counter, ratio_normal_form * weight_normal_form, ratio_normal_form * weight_normal_form/counter)\n s += format_s % ('soundex van normal_form', ratio_normal_form_soundex, weight_normal_form_soundex,weight_normal_form_soundex/counter, ratio_normal_form_soundex* weight_normal_form_soundex, ratio_normal_form_soundex * weight_normal_form_soundex/counter)\n s += format_s % ('soundex van geslachtsnaam1', ratio_geslachtsnaam1, weight_geslachtsnaam1,weight_geslachtsnaam1/counter, ratio_geslachtsnaam1 * weight_geslachtsnaam1, ratio_geslachtsnaam1 * weight_geslachtsnaam1/counter)\n s += format_s % ('geslachtsnaam', ratio_geslachtsnaam2, weight_geslachtsnaam2,weight_geslachtsnaam2/counter, ratio_geslachtsnaam2 *weight_geslachtsnaam2 , ratio_geslachtsnaam2 * weight_geslachtsnaam2/counter)\n s += format_s % ('initials', ratio_initials, weight_initials, weight_initials/counter, ratio_initials *weight_initials, ratio_initials * weight_initials/counter)\n s += '\\tTOTAL (numerator) | %s (counter = %s)\\n' % (counter, numerator)\n \n return s\n return final_ratio","def edit_distance(str1, str2):\r\n pass","def fuzzy_token_sort_ratio(thing_1, thing_2):\n return fuzz.token_sort_ratio(thing_1, thing_2)","def Path_Similarity(word1, word2):\n\n # Initial test to confirm unique nouns, otherwise passes back 1\n\n if word1 == word2:\n return 1, word1\n\n # Sets up Initial Variables & Dictionaries\n\n stepup1 = [word1]\n stepup2 = [word2]\n dict1= {}\n dict2= {}\n currentstep1 = []\n currentstep2 = []\n\n # Iterates through a loop an arbitrary # of times, adding new hypernyms\n # for each word to individual dictionaries with the number of iterations\n # as the key to the dictionary. The two dictionaries are saved perpetually\n\n for la in range(50):\n for i in range(len(stepup1)):\n currentstep1 += (stepup1[i].hypernyms())\n for syn in stepup1:\n dict1[syn] = la\n for i in range(len(stepup2)):\n currentstep2 = (stepup2[i].hypernyms())\n for syn in stepup2:\n dict2[syn] = la\n\n # Variables are reset and converted to continue the next stage of the loop\n\n stepup1 = currentstep1\n stepup2 = currentstep2\n currentstep1 = []\n currentstep2 = []\n\n\n # Each loop the dictionaries are checked for matches. I have confirmed that\n # checking each cycle is faster than checking at the end of an arbitrary\n # number of cycles.\n\n # Removes applied words as Possible Subsumers Per Fridays Clas\n dict1.pop(word1)\n dict2.pop(word2)\n\n #Gets possible Least Common Subsumers\n dict1Set = set(dict1)\n dict2Set = set(dict2)\n d = {}\n for name in dict1Set.intersection(dict2Set):\n d[name] = dict1[name]\n pos_lcs = [key for min_value in (min(d.values()),) for key in d if d[key] == min_value]\n\n #Returns Actual LCS\n key_lcs = []\n for i in pos_lcs:\n key_lcs.append(shortestPath(wn.synset('entity.n.01'),i))\n lcs = (pos_lcs[key_lcs.index(max(key_lcs))])\n\n #Returns path Similarity Value and Synset of LCS; Must Error Proof\n\n return 1/(dict1[lcs] + dict2[lcs]), lcs","def compare_str(seq1, seq2):\n if seq1 == seq2:\n return 1\n ld = Levenshtein.distance(seq1, seq2)\n longest = len(seq1 if len(seq1) > len(seq2) else seq2)\n return (longest - ld) / longest","def wer(self, s1, s2):\n\n # build mapping of words to integers\n b = set(s1.split() + s2.split())\n word2char = dict(zip(b, range(len(b))))\n\n # map the words to a char array (Levenshtein packages only accepts\n # strings)\n w1 = [chr(word2char[w]) for w in s1.split()]\n w2 = [chr(word2char[w]) for w in s2.split()]\n\n return Lev.distance(''.join(w1), ''.join(w2))","def calculate_score(s1, s2, l1, l2, startpoint):\n\n matched = \"\" # to hold string displaying alignments\n score = 0\n for i in range(l2):\n if (i + startpoint) < l1:\n if s1[i + startpoint] == s2[i]: # if the bases match\n matched = matched + \"*\" # * indicates a match\n score = score + 1\n else:\n matched = matched + \"-\" # - indicates no match\n\n return score","def score_match(first_string, second_string, domain_score=False):\n score = 0\n\n if first_string == second_string:\n return SCORE_THRESHOLD_NORMAL\n\n if domain_score:\n if remove_tld(first_string) == remove_tld(second_string):\n return SCORE_THRESHOLD_NORMAL\n\n if second_string in first_string:\n return SCORE_THRESHOLD_NORMAL\n\n if domain_score:\n first_string = remove_tld(first_string)\n second_string = remove_tld(second_string)\n\n l_distance = Levenshtein.distance(first_string, second_string)\n fuzz_ratio = fuzz.token_sort_ratio(first_string, second_string)\n\n if l_distance <= 2:\n score = 50 + 25 * (2 - l_distance)\n\n elif fuzz_ratio > 80:\n score = fuzz_ratio - 25\n\n first_len = len(first_string)\n second_len = len(second_string)\n\n if first_len > second_len / 2 and first_len > 4:\n score += fuzzy_score_string(first_string, second_string)\n\n return score","def _pairwise_dist(self,seq1,seq2):\n \n return jf.damerau_levenshtein_distance(str(seq1), str(seq2))","def optimal_string_alignment_similarity(s1, s2):\n max_cost = max(len(s1), len(s2))\n\n if max_cost == 0:\n return 1.0\n\n return 1.0 - float(optimal_string_alignment_distance(s1, s2)) / max_cost","def needle_diff(left_struc, right_struc, key, minimal=True):\n if type(left_struc) not in (list, tuple):\n return keyset_diff(left_struc, right_struc, key, minimal)\n assert type(right_struc) in (list, tuple)\n\n down_col = 0\n lastrow = [\n [[key + [sub_i]] for sub_i in range(i)]\n for i in range(len(left_struc), -1, -1)\n ]\n\n def modify_cand():\n \"\"\"Build the candidate diff that involves (potentially) modifying an\n element.\"\"\"\n if col_i + 1 < len(lastrow):\n return (lastrow[col_i + 1] +\n diff(left_elem, right_elem, key=key + [left_i],\n minimal=minimal, verbose=False))\n\n def delete_cand():\n \"\"\"Build the candidate diff that involves deleting an element.\"\"\"\n if row:\n return row[0] + [[key + [left_i]]]\n\n def append_cand():\n \"\"\"Build the candidate diff that involves appending an element.\"\"\"\n if col_i == down_col:\n return (lastrow[col_i] +\n [[key + [append_key(lastrow[col_i], left_struc, key)],\n right_elem]])\n\n for right_i, right_elem in enumerate(right_struc):\n first_left_i = min(right_i, len(left_struc) - 1)\n left_elems = left_struc[first_left_i:]\n row = []\n\n for left_i, left_elem in enumerate(left_elems, first_left_i):\n col_i = len(left_struc) - left_i - 1\n cands = [c for c in (modify_cand(), delete_cand(), append_cand())\n if c is not None]\n winner = min(cands, key=lambda d: len(compact_json_dumps(d)))\n row.insert(0, winner)\n\n lastrow = row\n return winner","def fuzzy_matching(mapper, fav_product, verbose=True):\n match_tuple = []\n # get match\n for title, idx in mapper.items():\n ratio = fuzz.ratio(title.lower(), fav_product.lower())\n if ratio >= 60:\n match_tuple.append((title, idx, ratio))\n # sort\n match_tuple = sorted(match_tuple, key=lambda x: x[2])[::-1]\n if not match_tuple:\n print('Oops! No match is found')\n return\n # if verbose:\n # print('Found possible matches in our database: {0}\\n'.format([x[0] for x in match_tuple]))\n return match_tuple[0][1]","def similar_text(word1, word2) -> float:\n\n return textdistance.overlap.similarity(word1, word2)","def compute_backpointers(s0, s1): #Tillverkar en array med backpointrs\r\n if s0 == None or s1 == None:\r\n raise Exception('Both s0 and s1 have to be set')\r\n rows = len(s0)+1 # antalet rader\r\n columns = len(s1)+1 # antalet kolumner\r\n\r\n ####### Tillverkar Levenshtein matrisen ########\r\n # Gör en tom matris med nollor\r\n distance = [[0 for y in range(len(s1)+1)] for x in range(len(s0)+1)]\r\n\r\n # Gör de yttre lagrerna i matrisen 0 -> len(str) vertikalt och horisontellt\r\n for i in range(1,rows):\r\n distance[i][0] = i\r\n for i in range(1,columns):\r\n distance[0][i] = i\r\n\r\n # Beräknar kostnaderna för varje plats inne i matrisen och sätter in dem\r\n # kollar om bokstaven på indexet i de två orden är samma i sådana fall kostar det 0\r\n # och skall ha samma värde som diagonalt innan, annars kostar det 1 från över eller underself.\r\n for column in range(1,columns):\r\n for row in range(1,rows): # kolla varje rad i vare column\r\n if s0[row-1] == s1[column -1]: # om det är samma bokstav kostar det 0\r\n c = 0\r\n else: # annars kostar det 2\r\n c = 2\r\n distance[row][column] = min(distance[row-1][column] + 1,distance[row][column-1] + 1,distance[row-1][column-1] + c)\r\n # raden över säger att det minsta värdet av över eller bredvid + 1 eller diagonalt innan plus (0 eller 2)\r\n # skall sättas in på platsen i matrisen.\r\n\r\n # det minsta avståndet är\r\n cost = distance[row][column]\r\n print(\"totalkostnaden är\")\r\n print(cost)\r\n\r\n\r\n ####### Tillverkar backptr-matrisen ########\r\n # Tillverkar en tom matris med [0,0] för till backptr-matrisen\r\n backptr = [[[0, 0] for y in range(len(s1)+1)] for x in range(len(s0)+1)]\r\n\r\n # går igenom platserna i Levenshtein matrisen bakirfrån\r\n for column in range(columns-1,0,-1):\r\n for row in range(rows-1,0,-1):\r\n # Om värdet till vänster är det minsta: peka vänster\r\n if distance[row][column-1] == min(distance[row-1][column-1],distance[row][column-1],distance[row-1][column]):\r\n backptr[row][column][0] = row\r\n backptr[row][column][1] = column -1\r\n # Om värdet över är det minsta: peka upp\r\n if distance[row-1][column] == min(distance[row-1][column-1],distance[row][column-1],distance[row-1][column]):\r\n backptr[row][column][0] = row -1\r\n backptr[row][column][1] = column\r\n # om värdet diagonalt är minst: peka på diagonalt\r\n if distance[row-1][column-1] == min(distance[row-1][column-1],distance[row][column-1],distance[row-1][column]):\r\n backptr[row][column][0] = row-1\r\n backptr[row][column][1] = column -1\r\n\r\n # Gör yttervärdena i matrisen, (OBS behövs ej)\r\n for i in range(0,rows):\r\n j = i-1\r\n backptr[i][0][0] = j\r\n backptr[i][0][1] = 0\r\n for i in range(0,columns):\r\n j = i-1\r\n backptr[0][i][1] = j\r\n backptr[0][i][0] = 0\r\n\r\n return backptr","def shortestPath(haystack, needle):\n if needle == haystack:\n return 0\n hyponyms = haystack.hyponyms()\n if len(hyponyms) > 0:\n return 1 + min([shortestPath(hypo, needle) for hypo in hyponyms])\n else:\n return 1000","def Extended_Lesk(word1,word2):\n\n #Creates a list of the word, and one layer of hyponyms\n list1 = [word1]\n for i in word1.hyponyms():\n list1.append(i)\n list2 = [word2]\n for i in word2.hyponyms():\n list2.append(i)\n\n #Creates a list of each of the above words' definitions, tokenized\n words1 = []\n words2 = []\n for i in list1:\n words1.append([l for l in word_tokenize(i.definition())])\n for i in list2:\n words2.append([l for l in word_tokenize(i.definition())])\n\n #Calculates the Maximum length of the Longest Definition\n lengths = []\n lengths.extend(len(l) for l in words1)\n lengths.extend(len(l) for l in words2)\n maxim = max(lengths)\n\n igramcount = []\n igram1 = []\n igram2 = []\n\n # Creates N-grams for each definition for each N, from 1:max(lengths)\n for i in range(int(maxim)):\n for g in words1:\n for l in ngrams(g, i+1):\n igram1.append(l)\n for f in words2:\n for m in ngrams(f, i+1):\n igram2.append(m)\n\n #For Each N-gram in the first set, which matches that of the Second set,\n # Denoting a form of \"Similarity\" between the two definitions,\n # Record the Value of N into a new List, igramcount.\n for x in set(igram1):\n if x in set(igram2):\n igramcount.append(i + 1)\n\n igram1 = []\n igram2 = []\n\n #Square the values of igramcount, and return the sum as the value of Extended Lesk.\n squared = [number**2 for number in igramcount]\n return sum(squared)","def fuzzy_equals(a, b):\n epsilon = 10**(-6) \n return (abs(a - b) < epsilon)","def min_dist_solution(self, words, keyword_dict = None):\r\n\r\n\t\t# default settings\r\n\t\tif keyword_dict == None:\r\n\t\t\tkeyword_dict = self.keyword_dict\r\n\r\n\t\tindexed_text = list(enumerate(words))\r\n\t\t# all found keyword positions\r\n\t\tkeyword_pos = []\r\n\t\tkw_counts = [(len(kw.split()),kw) for kw in keyword_dict]\r\n\t\tkw_length_set = set((l[0] for l in kw_counts))\r\n\t\t\r\n\t\t# seperate keywords by their length\r\n\t\tfor length in kw_length_set:\r\n\t\t\tkw_lgram = ngrams(indexed_text, length)\r\n\t\t\t# start, end, ngram token\r\n\t\t\tkw_lgram_text = [(g[0][0],g[-1][0],' '.join([token[1] for token in g])) \r\n\t\t\t\t\t\t\t for g in kw_lgram]\r\n\t\t\tfixed_length_kw = [kw[1] for kw in kw_counts if kw[0] == length]\r\n\t\t\t\r\n\t\t\tfixed_keyword_pos = [(kw_s,kw_e,token) for kw_s,kw_e,token in kw_lgram_text\r\n\t\t\t \t\t\t\t\t if token in fixed_length_kw]\r\n\t\t\tkeyword_pos += fixed_keyword_pos\r\n\t\t# all found distances\r\n\t\tdistances = []\r\n\t\tfor kw_s,kw_e,kw in keyword_pos:\r\n\t\t\tdistance = keyword_dict[kw]['distance']\r\n\t\t\t# TODO handle case when value we search for is consisted of multiple words\r\n\t\t\tregex_pattern = keyword_dict[kw]['regex']\r\n\t\t\tsearch_direction = keyword_dict[kw]['search_direction']\r\n\t\t\t# start of the block\r\n\t\t\tstart = kw_s - distance if kw_s-distance > 0 else 0\r\n\t\t\t# end of the block\r\n\t\t\tend = kw_e + distance\r\n\t\t\tif search_direction == 'right':\r\n\t\t\t\tsearchable_block = indexed_text[kw_e:end]\r\n\t\t\telif search_direction == 'left':\r\n\t\t\t\tsearchable_block = indexed_text[start:kw_s]\r\n\t\t\telif search_direction == 'both':\r\n\t\t\t\tsearchable_block = indexed_text[start:end]\r\n\t\t\telse:\r\n\t\t\t\t# mb hanlde search_direction value\r\n\t\t\t\tsearchable_block = []\r\n\t\t\t\r\n\t\t\tvalue_pos = [index for index,value in searchable_block\r\n\t\t\t\t\t\t if re.search(regex_pattern,value)]\r\n\t\t\tdistance = [(self.dist(vp,kw_s,kw_e),vp,kw) for vp in value_pos]\r\n\r\n\t\t\tdistances += distance\r\n\t\tif len(distances) == 0:\r\n\t\t\treturn ('not found', None,'no kw')\r\n\t\telse:\r\n\t\t\tmin_distance,found_target_pos,kw = min(distances)\r\n\t\t\treturn words[found_target_pos],found_target_pos,kw","def edit_distance(wordA, wordB):\n if not isinstance(wordA,list):\n lettersA = tamil.utf8.get_letters(wordA)\n else:\n lettersA = wordA\n\n if not isinstance(wordB,list):\n lettersB = tamil.utf8.get_letters(wordB)\n else:\n lettersB = wordB\n n_A = len(lettersA)\n n_B = len(lettersB)\n dist_AB = [[0 for i in range(0, n_B + 1)] for i in range(0, (n_A + 1))]\n # Target prefix reached by insertion\n for j in range(1, n_B + 1):\n dist_AB[0][j] = j\n for i in range(1, n_A + 1):\n dist_AB[i][0] = i\n for j in range(1, n_B + 1):\n for i in range(1, n_A + 1):\n if lettersA[i - 1] == lettersB[j - 1]:\n new_dist = dist_AB[i - 1][j - 1]\n else:\n new_dist = min(\n [\n dist_AB[i - 1][j] + 1,\n dist_AB[i][j - 1] + 1,\n dist_AB[i - 1][j - 1] + 1,\n ]\n ) # del, ins, or sub\n dist_AB[i][j] = new_dist\n return dist_AB[-1][-1]","def distance_between_pattern_and_strings(pattern, dna):\n\n k = len(pattern)\n distance = 0\n\n for text in dna:\n hamming_distance = 1000000\n for i in range(len(text) - k + 1):\n if hamming_distance > compute_hamming_distance(pattern, text[i:i + k]):\n hamming_distance = compute_hamming_distance(pattern, text[i:i + k])\n distance = distance + hamming_distance\n return distance","def compare_tokenized(repairmsg, targetmsg):\n nearest = -1\n\n # Cartesian product of tokens in either msg\n token_pairs = product(repairmsg.tokenized(), targetmsg.tokenized())\n\n # Reduce to unique pairs of inequivalent tokens\n # This used to change order of r and t but now we keep them...\n tokens = list(set((r, t)# if r < t else (t, r)\n for r, t in token_pairs\n if r != t))\n\n # Get minimum positive dist (distances <0 are edit distances above the\n # short-circuit threshold of our Levenshtein distance function).\n distances = [compare_token(r, t) for r, t in tokens]\n\n outputs = [(repair, target, dist)\n for ((repair, target), dist) in zip(tokens, distances)\n if dist > 0]\n if not outputs:\n return -1\n\n # min() will return the tuple with lowest dist\n repair, target, dist = min(outputs, key=lambda tup: tup[2]) # [2] is dist\n return repair, target, dist","def suggest(word, cutoff=0.77):\n if word in LOOKUP_TABLE:\n return LOOKUP_TABLE[word]\n\n guess = difflib.get_close_matches(word, MOST_COMMON_DOMAINS, n=1, cutoff=cutoff)\n if guess and len(guess) > 0:\n return guess[0]\n return word","def compare_junctions(\n r1: BioReaders.GMAPSAMRecord,\n r2: BioReaders.GMAPSAMRecord,\n internal_fuzzy_max_dist: int = 0,\n max_5_diff: int = 999999,\n max_3_diff: int = 999999,\n) -> str:\n # assert internal_fuzzy_max_dist >= 0\n # assert max_5_diff >= 0\n # assert max_3_diff >= 0\n strand = r1.strand\n found_overlap = False\n # super/partial --- i > 0, j = 0\n # exact/partial --- i = 0, j = 0\n # subset/partial --- i = 0, j > 0\n for i, x in enumerate(r1.segments):\n # find the first matching r2, which could be further downstream\n for j, y in enumerate(r2.segments):\n if i > 0 and j > 0:\n break\n if overlaps(x, y) > 0:\n found_overlap = True\n break\n if found_overlap:\n break\n if not found_overlap:\n return \"nomatch\"\n # now we have r1[i] matched to r2[j]\n # check that r1[i] and r2[j] match within 5'/3' max diff\n if strand == \"+\":\n if (\n abs(r1.segments[i].start - r2.segments[j].start) > max_5_diff\n or abs(r1.segments[i].end - r2.segments[j].end) > max_3_diff\n ):\n return \"partial\"\n else:\n if (\n abs(r1.segments[i].start - r2.segments[j].start) > max_3_diff\n or abs(r1.segments[i].end - r2.segments[j].end) > max_5_diff\n ):\n return \"partial\"\n\n # if just one exon, then must have less than 5'/3' diff\n # pdb.set_trace()\n\n if len(r1.segments) == 1:\n if len(r2.segments) == 1:\n # if both are single-exon, check that they have less than 5'/3' diff\n if (\n abs(r1.segments[0].start - r2.segments[0].start) <= max_5_diff\n and abs(r1.segments[0].end - r2.segments[0].end) <= max_3_diff\n ):\n return \"exact\"\n else:\n return \"partial\"\n else:\n # case: r1 single exon, r2 multi-exon\n # check that the matching exon is within difference\n # and that the r1 exon does NOT overlap with previous or later exons in r2\n if (\n abs(r1.segments[0].end - r2.segments[j].end) <= max_3_diff\n and abs(r1.segments[0].start - r2.segments[j].start) <= max_5_diff\n and (\n (j == 0 and r1.segments[0].end < r2.segments[1].start)\n or (\n j >= 1\n and r1.segments[0].start > r2.segments[j - 1].end\n and (\n j == len(r2.segments) - 1\n or r1.segments[0].end < r2.segments[j + 1].start\n )\n )\n )\n ):\n return \"subset\"\n else:\n return \"partial\"\n else:\n if len(r2.segments) == 1:\n # case: r1 multi exon, r2 single exon\n # r1.segments[i] matches r2.segments[0]\n # need to check that the r2, being single exon, did not overlap with previous or later r1 exons\n # and also the matching r1, r2 exon does not have huge 5'/3' difference\n if (\n (i == 0 or r1.segments[i - 1].end < r2.segments[0].start)\n and (\n i == len(r1.segments) - 1\n or r1.segments[i].start > r2.segments[0].end\n )\n and (abs(r1.segments[i].start - r2.segments[0].start) <= max_5_diff)\n and (abs(r1.segments[i].end - r2.segments[0].end) <= max_3_diff)\n ):\n return \"super\"\n else:\n return \"partial\"\n else: # both r1 and r2 are multi-exon, check that all remaining junctions agree\n k = 0\n while i + k + 1 < len(r1.segments) and j + k + 1 < len(r2.segments):\n if (\n abs(r1.segments[i + k].end - r2.segments[j + k].end)\n > internal_fuzzy_max_dist\n or abs(r1.segments[i + k + 1].start - r2.segments[j + k + 1].start)\n > internal_fuzzy_max_dist\n ):\n return \"partial\"\n k += 1\n # print i, j, k\n # check that the last matching exon, the ends are with max 5'/3' diff\n if strand == \"+\":\n if abs(r1.segments[i + k].end - r2.segments[j + k].end) > max_3_diff:\n return \"partial\"\n else:\n if abs(r1.segments[i + k].end - r2.segments[j + k].end) > max_5_diff:\n return \"partial\"\n\n if i + k + 1 == len(r1.segments):\n if j + k + 1 == len(r2.segments):\n if i == 0:\n if j == 0:\n return \"exact\"\n else:\n return \"subset\" # j > 0\n else:\n return \"super\"\n else: # r1 is at end, r2 not at end\n if i == 0:\n return \"subset\"\n else: # i > 0\n if (\n abs(r1.segments[i + k - 1].end - r2.segments[j + k - 1].end)\n > internal_fuzzy_max_dist\n or abs(r1.segments[i + k].start - r2.segments[j + k].start)\n > internal_fuzzy_max_dist\n ):\n return \"partial\"\n else:\n return \"concordant\"\n else: # r1 not at end, r2 must be at end\n if j == 0:\n return \"super\"\n else:\n if (\n abs(r1.segments[i + k - 1].end - r2.segments[j + k - 1].end)\n > internal_fuzzy_max_dist\n or abs(r1.segments[i + k].start - r2.segments[j + k].start)\n > internal_fuzzy_max_dist\n ):\n return \"partial\"\n else:\n return \"concordant\"","def similar_string_fast(first_string, second_string):\n partial_score = fuzz.ratio(first_string, second_string)\n token_score = fuzz.token_set_ratio(first_string, second_string)\n\n if max(partial_score, token_score) >= SCORE_THRESHOLD_FAST:\n return True\n\n return False","def edit_distance(str1, str2):\n\n if not str1:\n return len(str2)\n if not str2:\n return len(str1)\n\n DP = [[-1 for __ in str2] for ___ in str1]\n DP[0][0] = 0 if str1[0] == str2[0] else 1\n\n\n for x, let1 in enumerate(str1):\n startat = 0\n if x == 0:\n startat = 1\n for y, let2 in enumerate(str2[startat:], startat):\n minimum = float('inf')\n if x != 0:\n minimum = min(DP[x-1][y] + 1, minimum)\n if y != 0:\n minimum = min(DP[x-1][y-1] + (0 if let1 == let2 else 1), minimum)\n if y != 0:\n minimum = min(DP[x][y-1] + 1, minimum)\n\n DP[x][y] = minimum\n\n return DP[len(str1) - 1][len(str2) - 1]","def GetSuggesteeSimilarity(suggestee1_tags, suggestee2_tags):\n total_size = len(suggestee1_tags) + len(suggestee2_tags)\n if total_size == 0:\n return 1.\n size_of_intersection = 0\n elems_in_first = {}\n for tag in suggestee1_tags:\n elems_in_first[tag] = True\n for tag in suggestee2_tags:\n if tag in elems_in_first:\n size_of_intersection += 1\n return size_of_intersection / (total_size - size_of_intersection)","def test_multiple_word(self):\n score = location.match_weight('weston super mare UK', ['weston super mare'])\n\n self.assertEqual(score, 1000)","def add_substring_match_features(self,lst1,lst2,normalize_factor = 1.):\n for i in range(self.RE_LOW,self.RE_HI+1):\n for j in range(self.WILD_LOW,self.WILD_HI+1):\n self.features.append(Measures.longest_substring_with_wildcards(lst1, lst2, i, j) / normalize_factor)","def getSuggestions(self, query): # a suggestions method for all the suggestions\r\n\r\n \r\n suggestions =[] # a new list to add all the suggested words\r\n\r\n j = len(query) # find length of the query \r\n list_of_req_strings = [i for i in self._languageSet if len(i) in ( j -1, j, j+ 1)] # a list for required strings with equal lenth of query\r\n # and words with length of query +1 and -1\r\n\r\n \r\n for word in list_of_req_strings: # a for loop to check all the saved strings with query\r\n if query == word: # if query is a legitimate word (equal to word in list)\r\n suggestions.append(word) # add it to the suggestions\r\n n = len(word) # find the length of each word\r\n match_Count = 0 # keep the count of matched letters\r\n for i in range(j): # a for loop with range of length of query\r\n if query[0].isupper(): # check if the first letter is upper case letter\r\n query, word = query.capitalize(), word.capitalize() # capitalize query and each word if query's first letter is a upper case letter\r\n if query[i] in word: # then check each letter of query in word\r\n match_Count += 1 # increase the macth count if matches\r\n else: # if first letter of query is not an upper case letter\r\n query, word = query.lower(), word.lower() # change query and each word to lower case\r\n if query[i] in word: # then check each letter of query in word\r\n match_Count += 1 # increase the macth count if matches\r\n\r\n if match_Count == (max(j, n) - 1): # compare the match count with the max letter string of query and word\r\n suggestions.append(word) # add the word if it is one edit distance\r\n if match_Count == len(word)+1: # if match count is one value more than the word\r\n if not word in suggestions: # if the word not in suggestions\r\n suggestions.append(word) # add the word to the suggestions list\r\n\r\n\r\n for k in range(j - 1): # a for loop with range of query length -1\r\n inverted_char_word = query[:k]+query[k+1]+query[k]+query[(k+2):] # check by changing two letters(neighbering letters) till last letter\r\n if inverted_char_word not in suggestions: # if the changed word not in suggestions\r\n if inverted_char_word in list_of_req_strings: # and in list_req_strings\r\n suggestions.append(inverted_char_word) # add the changed word to the suggestions\r\n\r\n return (sorted(suggestions)) # return the sorted suggestions list\r","def string_edit_dist(str1, str2):\n sm = edit_distance.SequenceMatcher(a=str1, b=str2)\n return sm.distance()","def test_jaro_winkler():\n assert textdistance.jaro_winkler(\"campell\", \"campbell\") == pytest.approx(0.9792, abs=0.01)\n assert textdistance.jaro_winkler(\"shakelford\", \"shakleford\") == pytest.approx(0.9848, abs=0.01)\n assert textdistance.jaro_winkler(\"dwayne\", \"duane\") == pytest.approx(0.84, abs=0.01)","def levenshtein_distance(s: Union[bytes, str], t: Union[bytes, str]) -> int:\n if s is None or t is None:\n raise ValueError(\"Strings must not be None\")\n\n n = len(s)\n m = len(t)\n\n if n == 0:\n return m\n elif m == 0:\n return n\n\n if n > m:\n tmp = s\n s = t\n t = tmp\n n = m\n m = len(t)\n\n p = [0] * (n + 1)\n d = [0] * (n + 1)\n\n for i in range(0, n + 1):\n p[i] = i\n\n for j in range(1, m + 1):\n if DEBUG_DISTANCE:\n if j % 100 == 0:\n print(\"DEBUG:\", int(j / (m + 1.0) * 100), \"%\\r\", end=' ', file=sys.stderr)\n t_j = t[j - 1]\n d[0] = j\n\n for i in range(1, n + 1):\n cost = 0 if s[i - 1] == t_j else 1\n # minimum of cell to the left+1, to the top+1, diagonally left and up +cost\n d[i] = min(min(d[i - 1] + 1, p[i] + 1), p[i - 1] + cost)\n\n _d = p\n p = d\n d = _d\n\n if DEBUG_DISTANCE:\n print(\"\\n\", file=sys.stderr)\n return p[n]","def needleman_wunsch(\n seq1, seq2, match=1, mismatch=-1, gap_open=-5, gap_extend=-3, at_genome_start=False\n):\n alignments = pairwise2.align.globalms(\n seq1,\n seq2,\n match,\n mismatch,\n gap_open,\n gap_extend,\n )\n # Alignments is a list of tuples. Each tuple has length 5. Entries:\n # 0: seq1 alignment (ie with dashes for indels)\n # 1: seq2 alignemnt\n # 2: alignment score\n # 4, 5: don't know (not using them)\n if len(alignments) == 1:\n return alignments[0][0], alignments[0][1]\n\n if at_genome_start:\n best_pos = last_gap_end_in_string(alignments[0][1])\n else:\n best_pos = alignments[0][1].find(\"-\")\n\n best = alignments[0]\n\n for a in alignments[1:]:\n if at_genome_start:\n gap_pos = last_gap_end_in_string(a[1])\n else:\n gap_pos = a[1].find(\"-\")\n\n if gap_pos > best_pos:\n best = a\n best_pos = gap_pos\n\n return best[0], best[1]","def score_function(word1, word2):\n if word2 == '':\n return len(word1)\n elif word1 == '':\n return len(word2)\n elif word1 == word2:\n return 0\n elif word1[0] == word2[0]:\n return 0 + score_function(word1[1:], word2[1:])\n else:\n add_char = 1 + score_function(word2[0] + word1[:], word2[:])\n sub_char = 1 + score_function(word1[1:], word2[1:])\n remove_char = 1 + score_function(word1[1:], word2[:])\n return min(add_char, sub_char, remove_char)\n # if word1 == word2: # Fill in the condition\n # # BEGIN Q6\n # return 0\n # # END Q6\n # elif word1[0] == word2[0]: # Feel free to remove or add additional cases\n # # BEGIN Q6\n # return score_function(word1[1:], word2[1:])\n # # END Q6\n # else:\n #\n # elif len(word1) > len(word2):\n # difference = len(word2) - len(word1)\n # word2 = word2[0:len(word1)]\n # return difference + score_function(word1, word2)\n # elif len(word1) == len(word2):\n # total = 0\n # for i in word1:\n # if word1[i] == word2[i]:\n # total += 1\n # return total\n # elif len(word1) < len(word2):\n # difference = len(word2) - len(word1)\n # word1 = word1 + word2[len(word1):]\n # return difference + score_function(word1, word2)\n # else:\n #\n # def add_char(word1, word2):\n # while len(word1) <= len(word2):\n # return swap_score(word1, word2)\n # return 0\n #\n # def remove_char(word1, word2):\n # while len(word1) >= len(word2):\n # if word1[0] != word2[0]:\n # return 1 + remove_char(word1[1:], word2[1:])\n # return 0\n #\n # def sub_char(word1, word2):\n # if len(word1) == len(word2):\n # if word1[0] == word2[0]:\n # return 0\n # else:\n # return 1 + sub_char(word1[1:], word2[1:])\n # return 0\n # # BEGIN Q6\n # return add_char(word1, word2) + remove_char(word1, word2) + sub_char(word1, word2)\n # # END Q6","def __init__(self) -> None:\n\n super(Levenshtein, self).__init__()","def hamdist(str1, str2):\n\n diffs = 0\n for ch1, ch2 in zip(str1, str2):\n if ch1 != ch2:\n diffs += 1\n return diffs","def add_substring_match_features(self,lst1,lst2,normalize_factor = 1.):\n for j in range(self.WILD_LOW,self.WILD_HI+1):\n self.features.append(Measures.longest_substring_with_wildcards(lst1, lst2, j) / normalize_factor)","def most_similar_matching(self):\n min_sim_thresh = float(self._conf.get(\"min_similarity_threshold\"))\n most_similar_words = self.model_request.most_similar(positive=[self.base_word],\n top_n=self._conf.get(\"max_similar_terms_threshold\"))\n\n # iterate through the most similar word list\n match_found = False\n for similar_word, sim in most_similar_words:\n if sim > min_sim_thresh and not match_found:\n\n # 4.1 - find exact match in ontology.\n result = self.graphdb.get_record_using_exact_matching(similar_word)\n\n if self.match_found(result):\n threshold_reached, result, cor_walk = self.check_match_results(result)\n if threshold_reached:\n match_found = True\n self.save_finding(self.ft_found_terms, similar_word, result,\n cor_walk, self._conf.get(\"FT_DIRECT\"))\n\n else:\n # 4.2 - Convert word into lemma and find exact match in ontology.\n match_found = self.modify_and_test_word(self.ft_found_terms, similar_word, self._conf.get(\"MOD_FT\"))\n\n artificial_results = self.graphdb.get_records_with_artificial_relation(similar_word)\n if len(artificial_results[\"results\"][\"bindings\"]) > 0:\n self.save_finding(self.artificial_found_terms, similar_word, artificial_results,\n None, self._conf.get(\"ARTIFICIAL_MATCH\"))\n\n self.sorted_ft_findings = self.sort_ft_similar_word_findings(self.ft_found_terms)","def iterated_lev_dist(a, b, tolerance=5):\n lenA, lenB = _len(a), _len(b)\n\n # Optimize away edge cases...\n if a == b:\n return 0\n\n # Lower bound is length diff, quit if length difference is too big\n if _abs(lenA - lenB) > tolerance:\n return -1\n\n # Quit early if we know the minimum number of substitutions to make will\n # already be too big\n min_substitutions = _len(_symdif({*a}, {*b})) / 2\n if min_substitutions > tolerance:\n return -1\n\n # We need 2 arrays, 1 larger than the compared\n slots = _len(b) + 1\n v0 = list(range(slots))\n v1 = [0] * slots\n\n # print(' ', ' '.join(t))\n # Walking over rows. Each row represents one step along the source string.\n # Last cell of last row gives us the edit distance.\n for i, A in enumerate(a):\n # First cell of each row is for comparison against empty string\n # the cost is always equal to length of source string walked so far\n v1[0] = i + 1\n\n for j, B in enumerate(b):\n delCost = v0[j + 1] + 1 # j+1 since the first value in the row\n # is distance from an empty str\n subCost = v0[j] + (A != B) # substitution\n insCost = v1[j] + 1 # the insert cost is always at least 1\n v1[j + 1] = _min(delCost, insCost, subCost)\n\n # When moving to next row, current row\n v0 = _lcopy(v1)\n # print(A, v0)\n return v0[-1]","def exact_distance_matcher_inefficient(database, query):\n from scipy.spatial.distance import cdist\n distances = cdist(query.reshape(1, -1), database.T)\n list_refined = np.argsort(distances, axis=1).T\n return list_refined","def name_match_score(card_name: str, query: str) -> float:\n # iterate over blocks of matching characters as returned by\n # difflib, to get\n # - \"match_size\", the number of matching characters\n # - \"match_cost\", the number of edit operations from the card name\n # to the search query\n if query.islower():\n card_name = card_name.lower()\n s = difflib.SequenceMatcher(str.isspace, query, card_name, autojunk=False)\n blocks = s.get_matching_blocks()\n match_size = 0\n match_cost = len(query)\n pos = 0\n for block in blocks:\n # we matched `block.size` characters and we skipped over the\n # substring `card_name[pos : block.b]`\n match_size += block.size\n num_unmatched_words = len(card_name[pos : block.b].split())\n if block.b < len(card_name):\n # cost 1 per word in the skipped substring\n match_cost += num_unmatched_words\n else:\n # special case: we skipped over the whole rest of the\n # string. cost 1 to skip the rest, plus 1 to skip to the\n # end of the current word if we were in the middle of one.\n if num_unmatched_words > 0:\n match_cost += 1\n if (\n num_unmatched_words > 1\n and pos < len(card_name)\n and not card_name[pos].isspace()\n and not card_name[pos] == \",\"\n ):\n match_cost += 1\n # set `pos` to the end of the matching block\n pos = block.b + block.size\n # difflib always produces a dummy block at the end.\n assert pos == len(card_name)\n return match_size / match_cost","def is_words_similar(string, model):\n\n if fuzz.ratio(string, model, score_cutoff=75):\n return True\n\n return False","def pos_match(self, a, b, threshold=0.5):\r\n # pos_a = map(self.get_wordnet_pos, nltk.pos_tag(word_tokenize(a)))\r\n # pos_b = map(self.get_wordnet_pos, nltk.pos_tag(word_tokenize(b)))\r\n pos_a = [self.get_wordnet_pos(token) for token in nltk.pos_tag(word_tokenize(a))]\r\n pos_b = [self.get_wordnet_pos(token) for token in nltk.pos_tag(word_tokenize(b))]\r\n lemmae_a = [self.lemmatizer.lemmatize(token.lower().strip(string.punctuation), pos) for token, pos in pos_a \\\r\n if pos == wordnet.NOUN and token.lower().strip(string.punctuation) not in self.stopwords]\r\n lemmae_b = [self.lemmatizer.lemmatize(token.lower().strip(string.punctuation), pos) for token, pos in pos_b \\\r\n if pos == wordnet.NOUN and token.lower().strip(string.punctuation) not in self.stopwords]\r\n\r\n # Calculate Jaccard similarity\r\n ratio = len(set(lemmae_a).intersection(lemmae_b)) / float(len(set(lemmae_a).union(lemmae_b)))\r\n return ratio\r\n # if ratio >= threshold: return ratio\r\n # return (ratio >= threshold)\r","def average_distance(l1, l2, distance_function=None):\n\n if not distance_function:\n distance_function = levenshtein_ratio\n counter = 0.0\n numerator = 0.0\n \n #compute array of values\n# if not l1 or not l2:\n# return 1.0\n #make l1 the shortes\n l1, l2 = len(l1)<len(l2) and (l1, l2) or (l2, l1)\n \n #compute the distrances\n distances = []\n for s1 in l1:\n distances += [(distance_function(s1, s2), s1, s2) for s2 in l2]\n# ls.sort(reverse=True)\n# distances.append((ls, s1))\n distances.sort(reverse=True)\n #compute maxima for each colum and each row\n done = set()\n for d, s1, s2 in distances:\n if s1 not in done and s2 not in done:\n done.add(s1)\n done.add(s2) \n counter += d\n numerator += 1\n #if there is a difference in length, we penalize for each item \n difference = len(l2) - len(l1)\n counter += .8 * difference\n numerator += difference\n if numerator == 0:\n return 1.0\n return counter/numerator","def weighted_levenshtein(seq1, seq2, weights, r=0.9, normalise=False):\n\tx1 = 1 + len(seq1)\n\tx2 = 1 + len(seq2)\n\n\talpha = r / ((1 - r) * average_distance)\n\n\t# Initialisation of the matrix\n\td = [] # Using Numpy structures for this is probably not more efficient\n\ttmp = 0.0\n\tfirst_line = [tmp]\n\tfor e in seq2:\n\t\ttmp += weights.get(e, 1)\n\t\tfirst_line.append(tmp)\n\td.append(first_line)\n\ttmp = 0\n\tfor e in seq1:\n\t\ttmp += weights.get(e, 1)\n\t\td.append([tmp] * x2)\n\n\t# Core of the algorithm\n\tfor i in range(1, x1):\n\t\tfor j in range(1, x2):\n\t\t\te1 = seq1[i-1]\n\t\t\te2 = seq2[j-1]\n\n\t\t\tw1 = weights.get(e1, 1)\n\t\t\tw2 = weights.get(e2, 1)\n\n\t\t\td[i][j] = min(\n\t\t\t\t(d[(i-1)][j] + w1), # Deletion of seq1[i]\n\t\t\t\t(d[i][(j-1)] + w2), # Insertion of seq2[j]\n\t\t\t\t(d[(i-1)][(j-1)] + (int(e1 != e2) * max(w1, w2))) # Substitution from seq1[i] to seq2[j]\n\t\t\t)\n\n\traw = d[-1][-1]\n\n\tif(normalise): return (raw / (d[0][-1] + d[-1][0]))\n\treturn raw","def Lev(self,testDf,listCourse,inCourse):\r\n #Obtain the couse names for the two courses provided\r\n A = self.trainDF['name'][listCourse]\r\n B = testDf['name'][inCourse]\r\n #Figure out the length of the longest course name.\r\n maxLen = max(len(A),len(B))\r\n #Calculate the compliment of the normalized Levenshtein distance. \r\n return 1-LV.distance(A,B)/maxLen","def test_single_word(self):\n score = location.match_weight('clevedon', ['clevedon'])\n\n self.assertEqual(score, 1000)","def fn(i1, i2):\n if i1 == len(word1): return len(word2) - i2\n if i2 == len(word2): return len(word1) - i1\n if word1[i1] == word2[i2]: return fn(i1+1, i2+1)\n return 1 + min(fn(i1+1,i2), fn(i1, i2+1))"],"string":"[\n \"def levenshtein_normalised(str1, str2):\\n\\treturn levenshtein(str1, str2, normalise=True)\",\n \"def levenshtein(str1, str2, normalise=False):\\n\\ttmp = Levenshtein.distance(str1, str2)\\n\\tif(normalise) and (len(str1) + len(str2)): tmp /= max(len(str1), len(str2))\\n\\treturn tmp\",\n \"def get_closest_levenshtein(word, possible_words, threshold):\\n result = None\\n min_distance = 10\\n for possible_word in possible_words:\\n word_distance = distance(word, possible_word)\\n if word_distance < min_distance:\\n result = possible_word\\n min_distance = word_distance\\n result = result if min_distance < threshold else None\\n return result, min_distance\",\n \"def fuzzy_score_string(first_string, second_string):\\n score = 0\\n\\n if len(first_string) < len(second_string):\\n shorter, longer = (first_string, second_string)\\n window_length = len(shorter)\\n\\n num_iterations = len(longer) - len(shorter) + 1\\n\\n for position in range(0, num_iterations):\\n window = longer[position:position + window_length]\\n l_ratio = Levenshtein.ratio(window, shorter) * 100\\n\\n if l_ratio > 60:\\n result = statistics.mean(\\n [100 - Levenshtein.distance(window, shorter) * 15, l_ratio, l_ratio])\\n\\n else:\\n result = l_ratio\\n\\n if result > score:\\n score = result\\n\\n else:\\n l_ratio = Levenshtein.ratio(first_string, second_string) * 100\\n score = statistics.mean(\\n [100 - Levenshtein.distance(first_string, second_string) * 15, l_ratio, l_ratio])\\n\\n simple = fuzz.ratio(first_string, second_string)\\n partial = fuzz.partial_ratio(first_string, second_string)\\n sort = fuzz.token_sort_ratio(first_string, second_string)\\n set_ratio = fuzz.token_set_ratio(first_string, second_string)\\n\\n score = max([score, simple, partial, sort, set_ratio])\\n\\n if score < 75:\\n score = 0\\n\\n return score * 0.85\",\n \"def levenshtein_distance(str1, str2):\\n m = len(str1)\\n n = len(str2)\\n lensum = float(m + n)\\n d = [] \\n for i in range(m+1):\\n d.append([i]) \\n del d[0][0] \\n for j in range(n+1):\\n d[0].append(j) \\n for j in range(1,n+1):\\n for i in range(1,m+1):\\n if str1[i-1] == str2[j-1]:\\n d[i].insert(j,d[i-1][j-1]) \\n else:\\n minimum = min(d[i-1][j]+1, d[i][j-1]+1, d[i-1][j-1]+2) \\n d[i].insert(j, minimum)\\n ldist = d[-1][-1]\\n ratio = (lensum - ldist)/lensum\\n return {'distance':ldist, 'ratio':ratio}\",\n \"def fuzzy_match_strings(ref, val):\\n if not ref or not val:\\n return 0\\n ref_q = to_q(ref)\\n val_q = to_q(val)\\n if ref_q or val_q:\\n return 100 if ref_q == val_q else 0\\n simplified_val = unidecode(val).lower()\\n simplified_ref = unidecode(ref).lower()\\n\\n # Return symmetric score\\n r1 = fuzz.token_sort_ratio(simplified_val, simplified_ref)\\n r2 = fuzz.token_sort_ratio(simplified_ref, simplified_val)\\n r2 = r1\\n return int(0.5*(r1+r2))\",\n \"def levenshtein(s1, s2):\\n if len(s1) < len(s2):\\n return levenshtein(s2, s1)\\n\\n # len(s1) >= len(s2)\\n if len(s2) == 0:\\n return len(s1)\\n\\n previous_row = range(len(s2) + 1)\\n for i, c1 in enumerate(s1):\\n current_row = [i + 1]\\n for j, c2 in enumerate(s2):\\n insertions = previous_row[j + 1] + 1 # j+1 instead of j since previous_row and current_row are one character longer\\n deletions = current_row[j] + 1 # than s2\\n substitutions = previous_row[j] + (c1 != c2)\\n current_row.append(min(insertions, deletions, substitutions))\\n previous_row = current_row\\n \\n return previous_row[-1]\",\n \"def levenshtein_distance(s1,s2):\\n\\n\\t\\tif len(s1) < len(s2):\\n\\t\\t\\treturn Searcher.levenshtein_distance(s2, s1)\\n\\n\\t\\t# len(s1) >= len(s2)\\n\\t\\tif len(s2) == 0:\\n\\t\\t\\treturn len(s1)\\n\\n\\t\\tprevious_row = range(len(s2) + 1)\\n\\t\\tfor i, c1 in enumerate(s1):\\n\\t\\t\\tcurrent_row = [i + 1]\\n\\t\\t\\tfor j, c2 in enumerate(s2):\\n\\t\\t\\t\\tinsertions = previous_row[j + 1] + 1 # j+1 instead of j since previous_row and current_row are one character longer\\n\\t\\t\\t\\tdeletions = current_row[j] + 1 # than s2\\n\\t\\t\\t\\tsubstitutions = previous_row[j] + (c1 != c2)\\n\\t\\t\\t\\tcurrent_row.append(min(insertions, deletions, substitutions))\\n\\t\\t\\tprevious_row = current_row\\n\\t\\t\\n\\t\\treturn previous_row[-1]\",\n \"def mismatch_search(haystack, needle, mismatches=1):\\n haystack = haystack.encode('utf-8');\\n needle = needle.encode('utf-8');\\n if not using_tre:\\n raise RBSError(\\\"tre isn't loaded.\\\")\\n fz = tre.Fuzzyness(maxerr=mismatches, maxsub=mismatches,\\n maxdel=0, maxins=0)\\n needle = \\\".*(%s).*\\\" % needle\\n pt = tre.compile(needle, tre.EXTENDED)\\n incidence = 0\\n while True:\\n m = pt.search(haystack, fz)\\n if m:\\n index = m.groups()[1][1]-1\\n incidence += 1\\n haystack = haystack[:index]\\n else:\\n break\\n return incidence\",\n \"def levenshtein(w1, w2):\\n\\n if len(w1) < len(w2):\\n # check if length of word1 is smaller than word2.\\n # if so, call function and switch parameters\\n return levenshtein(w2, w1)\\n elif len(w1) == 0:\\n # if the length of word1 equals 0, that means that\\n # the Lev' distance is the length of word2\\n return len(w2)\\n elif len(w2) == 0:\\n # if the length of word2 equals 0, that means that\\n # the Lev' distance is the length of word1\\n return len(w1)\\n elif w1 == w2:\\n # check if words are simply the same\\n return 0\\n\\n # thanks to the check above, we can assume that w2 is the longest word\\n # we use this information to determine the range of 'previous'\\n previous = range(len(w2) + 1)\\n\\n # iterate over the characters of the first word\\n for a, char1 in enumerate(w1):\\n current = [a + 1]\\n # iterate over the characters of the second word\\n for b, char2 in enumerate(w2):\\n inserts = previous[b + 1] + 1\\n deletions = current[b] + 1\\n subs = previous[b] + (char1 != char2)\\n current.append(min(inserts, deletions, subs))\\n previous = current\\n return previous[-1]\",\n \"def distance(str1, str2):\\n return levenshtein.normalized_distance(str1, str2)\",\n \"def levenshteinDistance(s1, s2):\\n singleLetterMapping = {DOWNLEFT: '1', DOWN:'2', DOWNRIGHT:'3',\\n LEFT:'4', RIGHT:'6',\\n UPLEFT:'7', UP:'8', UPRIGHT:'9'}\\n\\n len1 = len([singleLetterMapping[letter] for letter in s1])\\n len2 = len([singleLetterMapping[letter] for letter in s2])\\n\\n matrix = list(range(len1 + 1)) * (len2 + 1)\\n for i in range(len2 + 1):\\n matrix[i] = list(range(i, i + len1 + 1))\\n for i in range(len2):\\n for j in range(len1):\\n if s1[j] == s2[i]:\\n matrix[i+1][j+1] = min(matrix[i+1][j] + 1, matrix[i][j+1] + 1, matrix[i][j])\\n else:\\n matrix[i+1][j+1] = min(matrix[i+1][j] + 1, matrix[i][j+1] + 1, matrix[i][j] + 1)\\n return matrix[len2][len1]\",\n \"def damerau_levenshtein_similarity(s1, s2):\\n max_cost = max(len(s1), len(s2))\\n\\n if max_cost == 0:\\n return 1.0\\n\\n return 1.0 - float(damerau_levenshtein_distance(s1, s2)) / max_cost\",\n \"def kmp_strstr(haystack, needle):\\r\\n def computeLPSArray(word):\\r\\n # The explaination of this function is in _LPSArray()\\r\\n lps = [0] * len(word)\\r\\n wordIdx = 0\\r\\n delta = 1\\r\\n while delta < len(word):\\r\\n while delta < len(word) and word[delta] == word[wordIdx]:\\r\\n lps[delta] = wordIdx + 1\\r\\n wordIdx += 1\\r\\n delta += 1\\r\\n if wordIdx != 0:\\r\\n wordIdx = lps[wordIdx-1]\\r\\n else:\\r\\n delta += 1\\r\\n return lps\\r\\n\\r\\n # handle special cases\\r\\n if haystack == needle:\\r\\n return [0]\\r\\n elif not needle:\\r\\n return [0]\\r\\n elif not haystack:\\r\\n return []\\r\\n # init lps table\\r\\n lps = computeLPSArray(needle)\\r\\n ans = []\\r\\n # main loop\\r\\n i_haystack = 0\\r\\n i_needle = 0\\r\\n while i_haystack < len(haystack):\\r\\n if haystack[i_haystack] == needle[i_needle]:\\r\\n i_haystack += 1\\r\\n i_needle += 1\\r\\n # print i_needle, i_haystack\\r\\n if i_needle == len(needle):\\r\\n ans.append(i_haystack - i_needle)\\r\\n i_needle = lps[i_needle-1]\\r\\n elif i_needle != 0:\\r\\n i_needle = lps[i_needle-1]\\r\\n else:\\r\\n i_haystack += 1\\r\\n\\r\\n return ans\",\n \"def levenshtein(proposed, gold, normalize=False):\\n lev_densities = []\\n for x, y in zip(proposed, gold):\\n score = editdistance.eval(x, y)\\n if normalize:\\n score /= len(y)\\n lev_densities.append(score)\\n return sum(lev_densities) / len(lev_densities)\",\n \"def get_best_match(query, corpus, step=4, flex=3, case_sensitive=False, verbose=False):\\n\\n def _match(a, b):\\n \\\"\\\"\\\"Compact alias for SequenceMatcher.\\\"\\\"\\\"\\n return SequenceMatcher(None, a, b).ratio()\\n\\n def scan_corpus(step):\\n \\\"\\\"\\\"Return list of match values from corpus-wide scan.\\\"\\\"\\\"\\n match_values = []\\n\\n m = 0\\n while m + qlen - step <= len(corpus):\\n match_values.append(_match(query, corpus[m : m-1+qlen]))\\n if verbose:\\n print(query, \\\"-\\\", corpus[m: m + qlen], _match(query, corpus[m: m + qlen]))\\n m += step\\n\\n return match_values\\n\\n def index_max(v):\\n \\\"\\\"\\\"Return index of max value.\\\"\\\"\\\"\\n return max(range(len(v)), key=v.__getitem__)\\n\\n def adjust_left_right_positions():\\n \\\"\\\"\\\"Return left/right positions for best string match.\\\"\\\"\\\"\\n # bp_* is synonym for 'Best Position Left/Right' and are adjusted \\n # to optimize bmv_*\\n p_l, bp_l = [pos] * 2\\n p_r, bp_r = [pos + qlen] * 2\\n\\n # bmv_* are declared here in case they are untouched in optimization\\n bmv_l = match_values[p_l / step]\\n bmv_r = match_values[p_l / step]\\n\\n for f in range(flex):\\n ll = _match(query, corpus[p_l - f: p_r])\\n if ll > bmv_l:\\n bmv_l = ll\\n bp_l = p_l - f\\n\\n lr = _match(query, corpus[p_l + f: p_r])\\n if lr > bmv_l:\\n bmv_l = lr\\n bp_l = p_l + f\\n\\n rl = _match(query, corpus[p_l: p_r - f])\\n if rl > bmv_r:\\n bmv_r = rl\\n bp_r = p_r - f\\n\\n rr = _match(query, corpus[p_l: p_r + f])\\n if rr > bmv_r:\\n bmv_r = rr\\n bp_r = p_r + f\\n\\n if verbose:\\n print(\\\"\\\\n\\\" + str(f))\\n print(\\\"ll: -- value: %f -- snippet: %s\\\" % (ll, corpus[p_l - f: p_r]))\\n print(\\\"lr: -- value: %f -- snippet: %s\\\" % (lr, corpus[p_l + f: p_r]))\\n print(\\\"rl: -- value: %f -- snippet: %s\\\" % (rl, corpus[p_l: p_r - f]))\\n print(\\\"rr: -- value: %f -- snippet: %s\\\" % (rl, corpus[p_l: p_r + f]))\\n\\n return bp_l, bp_r, _match(query, corpus[bp_l : bp_r])\\n\\n if not case_sensitive:\\n query = query.lower()\\n corpus = corpus.lower()\\n\\n qlen = len(query)\\n\\n if flex >= qlen/2:\\n print(\\\"Warning: flex exceeds length of query / 2. Setting to default.\\\")\\n flex = 3\\n\\n match_values = scan_corpus(step)\\n pos = index_max(match_values) * step\\n\\n pos_left, pos_right, match_value = adjust_left_right_positions()\\n\\n return corpus[pos_left: pos_right].strip(), match_value\",\n \"def lev_dist(s1, s2):\\n\\n if s1 is None or s2 is None:\\n return np.NaN\\n if pd.isnull(s1) or pd.isnull(s2):\\n return np.NaN\\n\\n # Create the similarity measure object\\n measure = sm.Levenshtein()\\n\\n s1 = gh.convert_to_str_unicode(s1)\\n s2 = gh.convert_to_str_unicode(s2)\\n\\n # Call the function to compute the distance measure.\\n return measure.get_raw_score(s1, s2)\",\n \"def iterative_levenshtein(s, t):\\n rows = len(s)+1\\n cols = len(t)+1\\n dist = [[0 for x in range(cols)] for x in range(rows)]\\n # source prefixes can be transformed into empty strings \\n # by deletions:\\n for i in range(1, rows):\\n dist[i][0] = i\\n # target prefixes can be created from an empty source string\\n # by inserting the characters\\n for i in range(1, cols):\\n dist[0][i] = i\\n \\n for col in range(1, cols):\\n for row in range(1, rows):\\n if s[row-1] == t[col-1]:\\n cost = 0\\n else:\\n cost = 1\\n dist[row][col] = min(dist[row-1][col] + 1, # deletion\\n dist[row][col-1] + 1, # insertion\\n dist[row-1][col-1] + cost) # substitution\\n #for r in range(rows):\\n #print(dist[r])\\n \\n \\n return dist[row][col]\",\n \"def edit_distance(str1, str2, reconstruct_answer=False, method=alignments.Levinshtein(),\\n swap_case_on_mismatch=True):\\n method = alignments.Levinshtein() if method is None else method\\n return align(str1, str2, reconstruct_answer, method, swap_case_on_mismatch)\",\n \"def levenshtein_distance(first, second):\\n if len(first) > len(second):\\n first, second = second, first\\n if len(second) == 0:\\n return len(first)\\n first_length = len(first) + 1\\n second_length = len(second) + 1\\n distance_matrix = [range(second_length) for x in range(first_length)]\\n for i in range(1, first_length):\\n for j in range(1, second_length):\\n deletion = distance_matrix[i-1][j] + 1\\n insertion = distance_matrix[i][j-1] + 1\\n substitution = distance_matrix[i-1][j-1]\\n if first[i-1] != second[j-1]:\\n substitution += 1\\n distance_matrix[i][j] = min(insertion, deletion, substitution)\\n\\n return distance_matrix[first_length-1][second_length-1]\",\n \"def levenshtein(seq1: str, seq2: str) -> int:\\n if seq1 == \\\"\\\":\\n return len(seq2)\\n if seq2 == \\\"\\\":\\n return len(seq1)\\n if seq1[-1] == seq2[-1]:\\n cost = 0\\n else:\\n cost = 1\\n \\n result = min([levenshtein(seq1[:-1], seq2) + 1,\\n levenshtein(seq1, seq2[:-1]) + 1,\\n levenshtein(seq1[:-1], seq2[:-1]) + cost ])\\n return result\",\n \"def _levenshtein_distance(t1: Trace, t2: Trace):\\n if t1.length > t2.length:\\n t1, t2 = t2, t1\\n\\n distances = range(t1.length + 1)\\n for i2, c2 in enumerate(t2.event_list):\\n distances_ = [i2 + 1]\\n for i1, c1 in enumerate(t1.event_list):\\n if c1 == c2:\\n distances_.append(distances[i1])\\n else:\\n distances_.append(1 + min((distances[i1], distances[i1 + 1], distances_[-1])))\\n distances = distances_\\n return distances[-1]\",\n \"def Levenshtein(a, b):\\n v0 = list(range(len(b)+1))\\n v1 = list(range(len(b)+1)) # Or whatever.\\n\\n for i in range(len(a)):\\n v1[0] = i + 1\\n\\n for j in range(len(b)):\\n deletionCost = v0[j + 1] + 1\\n insertionCost = v1[j] + 1\\n substitutionCost = v0[j] if a[i] == b[j] else v0[j]+1\\n v1[j + 1] = min(deletionCost, insertionCost, substitutionCost)\\n\\n v1, v0 = v0, v1\\n return v0[len(b)]\",\n \"def damerau_levenshtein_distance(s1, s2):\\n\\n utils.check_for_none(s1, s2)\\n utils.check_for_type(str, s1, s2)\\n\\n # s1 = utils.unicode_normalize(s1)\\n # s2 = utils.unicode_normalize(s2)\\n\\n n1, n2 = len(s1), len(s2)\\n infinite = n1 + n2\\n\\n char_arr = defaultdict(int)\\n dp = [[0] * (n2 + 2) for _ in range(n1 + 2)]\\n\\n dp[0][0] = infinite\\n for i in range(0, n1 + 1):\\n dp[i + 1][0] = infinite\\n dp[i + 1][1] = i\\n for i in range(0, n2 + 1):\\n dp[0][i + 1] = infinite\\n dp[1][i + 1] = i\\n\\n for i in range(1, n1 + 1):\\n db = 0\\n for j in range(1, n2 + 1):\\n i1 = char_arr[s2[j - 1]]\\n j1 = db\\n cost = 1\\n if s1[i - 1] == s2[j - 1]:\\n cost = 0\\n db = j\\n\\n dp[i + 1][j + 1] = min(dp[i][j] + cost,\\n dp[i + 1][j] + 1,\\n dp[i][j + 1] + 1,\\n dp[i1][j1] + (i - i1 - 1) + 1 + (j - j1 - 1))\\n char_arr[s1[i - 1]] = i\\n\\n return dp[n1 + 1][n2 + 1]\",\n \"def get_fuzzy_match(object, answer, threshold=80):\\n answer_phrase = generate_ngrams(answer)\\n if answer_phrase:\\n best_match = [fuzz.ratio(object, phr) for phr in answer_phrase]\\n if np.max(best_match)>threshold:\\n return np.max(best_match), answer_phrase[np.argmax(best_match)]\\n else:\\n return 0,''\\n else:\\n return 0, ''\",\n \"def test_string_similarity_constraint():\\n f = SimilarityConstraint(func=LevenshteinDistance(), pred=GreaterThan(0.5))\\n assert f('BROOKLYN', 'BROKLYN')\\n assert not f('BROOKLYN', 'QUEENS')\",\n \"def fuzzy_match(replist, wordset):\\n matches = []\\n for rep in replist:\\n for word in wordset:\\n matches.append((Levenshtein.distance(str(rep), word), word, rep))\\n\\n matches.sort(key=lambda x: (x[0], x[2].weight))\\n try:\\n return str(matches[0][2]), matches[0][1]\\n except IndexError:\\n return (\\\"\\\", \\\"\\\")\",\n \"def iterative_levenshtein(self, w1, d1, w2, d2):\\n rows = len(w1) + 1\\n cols = len(w2) + 1\\n dist = [[0 for x in range(cols)] for x in range(rows)]\\n # source prefixes can be transformed into empty strings\\n # by deletions:\\n for i in range(1, rows):\\n dist[i][0] = i\\n # target prefixes can be created from an empty source string\\n # by inserting the characters\\n for i in range(1, cols):\\n dist[0][i] = i\\n\\n for col in range(1, cols):\\n for row in range(1, rows):\\n if w1[row - 1] == w2[col - 1]:\\n cost = 0\\n else:\\n cost = 1\\n dist[row][col] = min(dist[row - 1][col] + 1, # deletion\\n dist[row][col - 1] + 1, # insertion\\n dist[row - 1][col - 1] + cost) # substitution\\n return dist[row][col] < 5\",\n \"def similarity(a, b):\\n distance = Levenshtein.distance(a, b)\\n return 1 - (distance / max((len(a), len(b))))\",\n \"def dameraulevenshtein(seq1, seq2):\\n # codesnippet:D0DE4716-B6E6-4161-9219-2903BF8F547F\\n # Conceptually, this is based on a len(seq1) + 1 * len(seq2) + 1 matrix.\\n # However, only the current and two previous rows are needed at once,\\n # so we only store those.\\n oneago = None\\n thisrow = list(range(1, len(seq2) + 1)) + [0]\\n for x in range(len(seq1)):\\n # Python lists wrap around for negative indices, so put the\\n # leftmost column at the *end* of the list. This matches with\\n # the zero-indexed strings and saves extra calculation.\\n twoago, oneago, thisrow = (oneago, thisrow, [0] * len(seq2) + [x + 1])\\n for y in range(len(seq2)):\\n delcost = oneago[y] + 1\\n addcost = thisrow[y - 1] + 1\\n subcost = oneago[y - 1] + (seq1[x] != seq2[y])\\n thisrow[y] = min(delcost, addcost, subcost)\\n # This block deals with transpositions\\n if (x > 0 and y > 0 and seq1[x] == seq2[y - 1]\\n and seq1[x - 1] == seq2[y] and seq1[x] != seq2[y]):\\n thisrow[y] = min(thisrow[y], twoago[y - 2] + 1)\\n return thisrow[len(seq2) - 1]\",\n \"def dameraulevenshtein(seq1, seq2):\\n # codesnippet:D0DE4716-B6E6-4161-9219-2903BF8F547F\\n # Conceptually, this is based on a len(seq1) + 1 * len(seq2) + 1 matrix.\\n # However, only the current and two previous rows are needed at once,\\n # so we only store those.\\n oneago = None\\n thisrow = list(range(1, len(seq2) + 1)) + [0]\\n for x in range(len(seq1)):\\n # Python lists wrap around for negative indices, so put the\\n # leftmost column at the *end* of the list. This matches with\\n # the zero-indexed strings and saves extra calculation.\\n twoago, oneago, thisrow = (oneago, thisrow, [0] * len(seq2) + [x + 1])\\n for y in range(len(seq2)):\\n delcost = oneago[y] + 1\\n addcost = thisrow[y - 1] + 1\\n subcost = oneago[y - 1] + (seq1[x] != seq2[y])\\n thisrow[y] = min(delcost, addcost, subcost)\\n # This block deals with transpositions\\n if (x > 0 and y > 0 and seq1[x] == seq2[y - 1]\\n and seq1[x - 1] == seq2[y] and seq1[x] != seq2[y]):\\n thisrow[y] = min(thisrow[y], twoago[y - 2] + 1)\\n return thisrow[len(seq2) - 1]\",\n \"def levenshtein_similarity(self, top, rows):\\n if len(rows) > 1:\\n return (\\n [(1 - editdistance.eval(top, rows[i]) / max(len(top), len(rows[i]))) for i in\\n range(0, len(rows))])\\n else:\\n return 1\",\n \"def dameraulevenshtein(seq1, seq2):\\n # Conceptually, this is based on a len(seq1) + 1 * len(seq2) + 1 matrix.\\n # However, only the current and two previous rows are needed at once,\\n # so we only store those.\\n oneago = None\\n thisrow = list(range(1, len(seq2) + 1)) + [0]\\n for x in range(len(seq1)):\\n # Python lists wrap around for negative indices, so put the\\n # leftmost column at the *end* of the list. This matches with\\n # the zero-indexed strings and saves extra calculation.\\n twoago, oneago, thisrow = oneago, thisrow, [0] * len(seq2) + [x + 1]\\n for y in range(len(seq2)):\\n delcost = oneago[y] + 1\\n addcost = thisrow[y - 1] + 1\\n subcost = oneago[y - 1] + (seq1[x] != seq2[y])\\n thisrow[y] = min(delcost, addcost, subcost)\\n # This block deals with transpositions\\n if (x > 0 and y > 0 and seq1[x] == seq2[y - 1]\\n and seq1[x-1] == seq2[y] and seq1[x] != seq2[y]):\\n thisrow[y] = min(thisrow[y], twoago[y - 2] + 1)\\n return thisrow[len(seq2) - 1]\",\n \"def levenshtein(source, target):\\n if len(source) < len(target):\\n return levenshtein(target, source)\\n\\n # So now we have len(source) >= len(target).\\n if len(target) == 0:\\n return len(source)\\n\\n # We call tuple() to force strings to be used as sequences\\n # ('c', 'a', 't', 's') - numpy uses them as values by default.\\n source = np.array(tuple(source))\\n target = np.array(tuple(target))\\n\\n # We use a dynamic programming algorithm, but with the\\n # added optimization that we only need the last two rows\\n # of the matrix.\\n previous_row = np.arange(target.size + 1)\\n for s in source:\\n # Insertion (target grows longer than source):\\n current_row = previous_row + 1\\n\\n # Substitution or matching:\\n # Target and source items are aligned, and either\\n # are different (cost of 1), or are the same (cost of 0).\\n current_row[1:] = np.minimum(\\n current_row[1:],\\n np.add(previous_row[:-1], target != s))\\n\\n # Deletion (target grows shorter than source):\\n current_row[1:] = np.minimum(\\n current_row[1:],\\n current_row[0:-1] + 1)\\n\\n previous_row = current_row\\n\\n return previous_row[-1]\",\n \"def spell_checker(input_string, lexical_tree=0, transform_list_in=[], transform_list_out=[], templates=[]):\\n dict = read_file('dict.txt').split()\\n word_list = list(set(re.split('\\\\W', input_string)))\\n word_list = [i for i in word_list if len(i) > 0]\\n print templates\\n levenshtein_distance_obj = levenshtein_distance.LevenshteinDistance(\\n templates=dict if templates == [] else templates, string_or_list=0)\\n print levenshtein_distance_obj.templates\\n for word in word_list:\\n right_word = levenshtein_distance_obj.levenshtein_distance(input_string=word, strategy=0, string_or_list=0,\\n case_sensitive=0, lexical_tree=lexical_tree,\\n transform_list_in=transform_list_in,\\n transform_list_out=transform_list_out)[1].lower()\\n input_string = re.sub('(\\\\W)' + word + '(\\\\W)', '\\\\g<1>' + right_word[1:] + '\\\\g<2>', input_string)\\n print right_word\\n return input_string\",\n \"def __levenshtein(a, b):\\n\\n n, m = len(a), len(b)\\n if n > m:\\n # Make sure n <= m, to use O(min(n,m)) space\\n a, b = b, a\\n n, m = m, n\\n\\n current = list(range(n + 1))\\n for i in range(1, m + 1):\\n previous, current = current, [i] + [0] * n\\n for j in range(1, n + 1):\\n add, delete = previous[j] + 1, current[j - 1] + 1\\n change = previous[j - 1]\\n if a[j - 1] != b[i - 1]:\\n change = change + 1\\n current[j] = min(add, delete, change)\\n\\n return current[n]\",\n \"def fuzzy_match(pattern, instring, adj_bonus=5, sep_bonus=10, camel_bonus=10,\\n lead_penalty=-3, max_lead_penalty=-9, unmatched_penalty=-1):\\n score, p_idx, s_idx, p_len, s_len = 0, 0, 0, len(pattern), len(instring)\\n prev_match, prev_lower = False, False\\n prev_sep = True # so that matching first letter gets sep_bonus\\n best_letter, best_lower, best_letter_idx = None, None, None\\n best_letter_score = 0\\n matched_indices = []\\n\\n while s_idx != s_len:\\n p_char = pattern[p_idx] if (p_idx != p_len) else None\\n s_char = instring[s_idx]\\n p_lower = p_char.lower() if p_char else None\\n s_lower, s_upper = s_char.lower(), s_char.upper()\\n\\n next_match = p_char and p_lower == s_lower\\n rematch = best_letter and best_lower == s_lower\\n\\n advanced = next_match and best_letter\\n p_repeat = best_letter and p_char and best_lower == p_lower\\n\\n if advanced or p_repeat:\\n score += best_letter_score\\n matched_indices.append(best_letter_idx)\\n best_letter, best_lower, best_letter_idx = None, None, None\\n best_letter_score = 0\\n\\n if next_match or rematch:\\n new_score = 0\\n\\n # apply penalty for each letter before the first match\\n # using max because penalties are negative (so max = smallest)\\n if p_idx == 0:\\n score += max(s_idx * lead_penalty, max_lead_penalty)\\n\\n # apply bonus for consecutive matches\\n if prev_match:\\n new_score += adj_bonus\\n\\n # apply bonus for matches after a separator\\n if prev_sep:\\n new_score += sep_bonus\\n\\n # apply bonus across camelCase boundaries\\n if prev_lower and s_char == s_upper and s_lower != s_upper:\\n new_score += camel_bonus\\n\\n # update pattern index iff the next pattern letter was matched\\n if next_match:\\n p_idx += 1\\n\\n # update best letter match (may be next or rematch)\\n if new_score >= best_letter_score:\\n # apply penalty for now-skipped letter\\n if best_letter is not None:\\n score += unmatched_penalty\\n best_letter = s_char\\n best_lower = best_letter.lower()\\n best_letter_idx = s_idx\\n best_letter_score = new_score\\n\\n prev_match = True\\n\\n else:\\n score += unmatched_penalty\\n prev_match = False\\n\\n prev_lower = s_char == s_lower and s_lower != s_upper\\n prev_sep = s_char in '_ '\\n\\n s_idx += 1\\n\\n if best_letter:\\n score += best_letter_score\\n matched_indices.append(best_letter_idx)\\n\\n return p_idx == p_len, score\",\n \"def needleMatching(self):\\n #productive\\n profprint()\\n modelNodes=slicer.mrmlScene.GetNodesByClass('vtkMRMLModelNode')\\n nbNode=modelNodes.GetNumberOfItems()\\n result=[]\\n found=[]\\n #print nbNode\\n for nthNode in range(nbNode):\\n node=slicer.mrmlScene.GetNthNodeByClass(nthNode,'vtkMRMLModelNode')\\n if node.GetID() not in found and node.GetAttribute('type')!='Validation':\\n dist=[]\\n polydata = node.GetPolyData()\\n if polydata!=None:\\n bounds = polydata.GetBounds()\\n for nthNode2 in range(nbNode):\\n node2=slicer.mrmlScene.GetNthNodeByClass(nthNode2,'vtkMRMLModelNode')\\n if node2.GetID() not in found and node2.GetAttribute('type')=='Validation':\\n polydata2 = node2.GetPolyData()\\n if polydata2!=None and polydata2.GetNumberOfPoints()>100 and polydata.GetNumberOfPoints()>100:\\n\\n axialDistance=self.distTip( int(node.GetID().strip('vtkMRMLModelNode')) , int(node2.GetID().strip('vtkMRMLModelNode')))\\n \\n dist.append([axialDistance,node2.GetID()])\\n # print axialDistance\\n \\n if dist!=[]:\\n match=[min(dist)[0],min(dist)[1],node.GetID()]\\n result.append(match)\\n found.append(min(dist)[1])\\n found.append(node.GetID()) \\n node.GetDisplayNode().SetSliceIntersectionVisibility(1)\\n # print result\\n return result\",\n \"def scientific_match_ratio(str1, str2, keywords):\\n\\n # Get rid of the numbers\\n str1_numberless = remove_numbers(str1)\\n str2_numberless = remove_numbers(str2)\\n\\n # Get the keywords and whatever remains after removing the keywords\\n str1_keywords, str1_remainder = get_common_words_in_description(str1_numberless, keywords)\\n str2_keywords, str2_remainder = get_common_words_in_description(str2_numberless, keywords)\\n\\n remainder_dist = string_num_matches(str1_remainder, str2_remainder)\\n common_keywords = str1_keywords.intersection(str2_keywords)\\n\\n common_keyword_total_len = 0\\n for common_kword in common_keywords:\\n common_keyword_total_len += len(common_kword)\\n\\n return (remainder_dist + common_keyword_total_len) * 1.0 / max(len(str1_numberless), len(str2_numberless))\",\n \"def levenshtein_distance(s, t, alphabet=string.printable, **weight_dict):\\n if len(s) == 0 or len(t) == 0:\\n return max([len(s), len(t)])\\n\\n rows = len(s) + 1\\n cols = len(t) + 1\\n\\n w = dict((x, (1, 1, 1)) for x in alphabet + alphabet.upper())\\n if weight_dict:\\n w.update(weight_dict)\\n\\n dist = [[0 for _ in range(cols)] for _ in range(rows)]\\n # source prefixes can be transformed into empty strings\\n # by deletions:\\n for row in range(1, rows):\\n dist[row][0] = dist[row - 1][0] + w[s[row - 1]][0]\\n # target prefixes can be created from an empty source string\\n # by inserting the characters\\n for col in range(1, cols):\\n dist[0][col] = dist[0][col - 1] + w[t[col - 1]][1]\\n\\n for col in range(1, cols):\\n for row in range(1, rows):\\n deletes = w[s[row - 1]][0]\\n inserts = w[t[col - 1]][1]\\n subs = max((w[s[row - 1]][2], w[t[col - 1]][2]))\\n if s[row - 1] == t[col - 1]:\\n subs = 0\\n else:\\n subs = subs\\n dist[row][col] = min(\\n dist[row - 1][col] + deletes,\\n dist[row][col - 1] + inserts,\\n dist[row - 1][col - 1] + subs,\\n ) # substitution\\n\\n return dist[row][col]\",\n \"def match_words_to_search(chunks, searchresult, compare_func, join=True):\\n wordlist = [hebstrip(w)[1] for w in word_bound.split(searchresult)]\\n wordset = set(wordlist)\\n genlist = [\\n m\\n for m in [\\n match_one(rlist, wordset)\\n for rlist in chunks.linked_heb\\n if rlist.data\\n ]\\n if m\\n ]\\n ours = [i[0] for i in genlist]\\n theirs = [i[1] for i in genlist]\\n if join:\\n return compare_func(\\\" \\\".join(ours), \\\" \\\".join(wordlist)), theirs\\n else:\\n return compare_func(ours, wordlist), theirs\",\n \"def needleMatching(self):\\r\\n # productive\\r\\n profprint()\\r\\n modelNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLModelNode')\\r\\n nbNode = modelNodes.GetNumberOfItems()\\r\\n result = []\\r\\n found = []\\r\\n # print nbNode\\r\\n for nthNode in range(nbNode):\\r\\n node = slicer.mrmlScene.GetNthNodeByClass(nthNode, 'vtkMRMLModelNode')\\r\\n if node.GetID() not in found and node.GetAttribute('type') != 'Validation':\\r\\n dist = []\\r\\n polydata = node.GetPolyData()\\r\\n if polydata != None:\\r\\n bounds = polydata.GetBounds()\\r\\n for nthNode2 in range(nbNode):\\r\\n node2 = slicer.mrmlScene.GetNthNodeByClass(nthNode2, 'vtkMRMLModelNode')\\r\\n if node2.GetID() not in found and node2.GetAttribute('type') == 'Validation':\\r\\n polydata2 = node2.GetPolyData()\\r\\n if polydata2 != None and polydata2.GetNumberOfPoints() > 100 and polydata.GetNumberOfPoints() > 100:\\r\\n tipDistance = self.distTip(int(node.GetID().strip('vtkMRMLModelNode')) , int(node2.GetID().strip('vtkMRMLModelNode')))\\r\\n baseDistance = self.distBase(int(node.GetID().strip('vtkMRMLModelNode')) , int(node2.GetID().strip('vtkMRMLModelNode')))\\r\\n name = node.GetName()\\r\\n manualName = name.lstrip('auto-seg_').lstrip('manual-seg_').lstrip('obturator-seg_').lstrip('0123456789').lstrip('-ID-vtkMRMLModelNode').lstrip('0123456789-')\\r\\n if manualName==node2.GetName(): dist.append([tipDistance, node2.GetID(), node2.GetName()])\\r\\n # print tipDistance\\r\\n if dist != []:\\r\\n match = [min(dist)[0], min(dist)[1], node.GetID(), min(dist)[2]]\\r\\n result.append(match)\\r\\n found.append(min(dist)[1])\\r\\n found.append(node.GetID())\\r\\n node.GetDisplayNode().SetSliceIntersectionVisibility(1)\\r\\n # print result\\r\\n return result\",\n \"def get_levenshtein_distance(a, b):\\r\\n n, m = len(a), len(b)\\r\\n if n > m:\\r\\n # Make sure n <= m, to use O(min(n,m)) space\\r\\n a, b = b, a\\r\\n n, m = m, n\\r\\n current_row = range(n+1) # Keep current and previous row, not entire matrix\\r\\n\\r\\n for i in range(1, m+1):\\r\\n previous_row, current_row = current_row, [i]+[0]*n\\r\\n for j in range(1, n+1):\\r\\n add, delete, change = previous_row[j]+1, current_row[j-1]+1, previous_row[j-1]\\r\\n if a[j-1] != b[i-1]:\\r\\n change += 1\\r\\n current_row[j] = min(add, delete, change)\\r\\n return current_row[n]\",\n \"def levenshtein_dist(s1, s2, dele, add, sub):\\n m = np.zeros((len(s1)+1, len(s2)+1), dtype=np.int)\\n p = np.zeros((len(s1)+1, len(s2)+1), dtype=np.float)\\n for i in range(len(s1)+1):\\n m[i, 0] = i\\n # compute probability for deletion\\n if i == 0:\\n p[i, 0] = 1\\n else:\\n ind = alphabet.index('@')\\n p[i, 0] = p[i-1, 0] * dele[ind, alphabet.index(s1[i-1])]\\n for j in range(len(s2)+1):\\n # compute probability for insertion\\n if j == 0:\\n p[0, j] = 1\\n else:\\n prev_char = '@' if j == 1 else s2[j-2]\\n p[0, j] = p[0, j-1] * add[alphabet.index(prev_char),\\n alphabet.index(s2[j-1])]\\n m[0, j] = j\\n for i in range(1, 1+len(s1)):\\n for j in range(1, len(s2)+1):\\n if s1[i-1] == s2[j-1]:\\n k = np.argmin([m[i-1, j] + 1, m[i, j-1] + 1, m[i-1, j-1]])\\n if k == 0:\\n # deletion\\n m[i, j] = m[i-1, j] + 1\\n prev_char = '@' if j == 1 else s2[j-2]\\n p[i, j] = p[i-1, j] * dele[alphabet.index(prev_char), alphabet.index(s1[i-1])]\\n elif k == 1:\\n # insertion\\n m[i, j] = m[i, j-1] + 1\\n prev_char = '@' if j == 1 else s2[j-2]\\n p[i, j] = p[i, j-1] * add[alphabet.index(prev_char), alphabet.index(s2[j-1])]\\n else:\\n # no mistake\\n m[i, j] = m[i-1, j-1]\\n p[i, j] = p[i-1, j-1]\\n else:\\n k = np.argmin([m[i-1, j] + 1, m[i, j-1] + 1, m[i-1, j-1] + 1])\\n if k == 0:\\n # deletion\\n m[i, j] = m[i-1, j] + 1\\n prev_char = '@' if j == 1 else s2[j-2]\\n p[i, j] = p[i-1, j] * dele[alphabet.index(prev_char), alphabet.index(s1[i-1])]\\n elif k == 1:\\n # insertion\\n m[i, j] = m[i, j-1] + 1\\n prev_char = '@' if j == 1 else s2[j-2]\\n p[i, j] = p[i, j-1] * add[alphabet.index(prev_char), alphabet.index(s2[j-1])]\\n else:\\n # substitution\\n m[i, j] = m[i-1, j-1] + 1\\n p[i, j] = p[i-1, j-1] * sub[alphabet.index(s1[i-1]), alphabet.index(s2[j-1])]\\n # recall that in sub[X, Y], Y is the correct word\\n\\n return m[len(s1), len(s2)], p[len(s1), len(s2)]\",\n \"def replace_by_lev(word):\\n minimum_lev = -1\\n maximum_jac = 0.0\\n results = {}\\n\\n it = iter(postings)\\n term = next(it)\\n\\n while True:\\n try:\\n if args.jaccard:\\n jac = jaccard(set(ngrams(word, 3)), set(ngrams(term, 3)))\\n # print(\\\"JAC => \\\" + str(jac))\\n if jac > maximum_jac:\\n maximum_jac = jac\\n # print(\\\"TERM\\\\t\\\" + term)\\n # print(\\\"JAC\\\\t\\\" + str(jac))\\n lev = levenshtein(word, term)\\n postings_length = len(postings[term])\\n if lev <= minimum_lev or minimum_lev == -1: # and (postings_length > occurrences):\\n minimum_lev = lev\\n results.update({term: (minimum_lev, postings_length)})\\n term = next(it)\\n else:\\n term = next(it)\\n\\n else:\\n lev = levenshtein(word, term)\\n postings_length = len(postings[term])\\n if lev <= minimum_lev or minimum_lev == -1: # and (postings_length > occurrences):\\n # print(\\\"MIN => \\\" + str(minimum_lev))\\n minimum_lev = lev\\n results.update({term: (minimum_lev, postings_length)})\\n term = next(it)\\n else:\\n term = next(it)\\n except StopIteration:\\n # print(results)\\n return results\",\n \"def ApproxStrMatch(pattern, text, d, debug = False):\\n\\tcount = 0\\n\\tindex = []\\n\\tfor i in range(len(text)-len(pattern)+1):\\n\\t\\tif debug:\\n\\t\\t\\tprint text[i:i+len(pattern)]\\n\\t\\t\\tprint HammingDist(text[i:i+len(pattern)], pattern)\\n\\t\\tif HammingDist(text[i:i+len(pattern)], pattern) <= d:\\n\\t\\t\\tcount += 1\\n\\t\\t\\tindex.append(i)\\n\\treturn index\",\n \"def dameraulevenshtein(self, seq1, seq2):\\n # codesnippet:D0DE4716-B6E6-4161-9219-2903BF8F547F\\n # Conceptually, this is based on a len(seq1) + 1 * len(seq2) + 1 matrix.\\n # However, only the current and two previous rows are needed at once,\\n # so we only store those.\\n oneago = None\\n thisrow = range(1, len(seq2) + 1) + [0]\\n for x in xrange(len(seq1)):\\n # Python lists wrap around for negative indices, so put the\\n # leftmost column at the *end* of the list. This matches with\\n # the zero-indexed strings and saves extra calculation.\\n twoago, oneago, thisrow = oneago, thisrow, [0] * len(seq2) + [x + 1]\\n for y in xrange(len(seq2)):\\n delcost = oneago[y] + 1\\n addcost = thisrow[y - 1] + 1\\n subcost = oneago[y - 1] + (seq1[x] != seq2[y])\\n thisrow[y] = min(delcost, addcost, subcost)\\n # This block deals with transpositions\\n if (x > 0 and y > 0 and seq1[x] == seq2[y - 1]\\n and seq1[x-1] == seq2[y] and seq1[x] != seq2[y]):\\n thisrow[y] = min(thisrow[y], twoago[y - 2] + 1)\\n return thisrow[len(seq2) - 1]\",\n \"def levenshteinDistance(s, t, asRatioOfMax = False):\\n\\n if s == None:\\n s = \\\"\\\"\\n if t == None:\\n t = \\\"\\\"\\n\\n if t == s:\\n return 0\\n if len(s) == 0:\\n return len(t)\\n if len(t) == 0:\\n return len(s)\\n\\n v0 = [x for x in range(len(t)+1)]\\n v1 = [0 for x in range(len(t)+1)]\\n\\n for i, si in enumerate(s):\\n\\n v1[0] = i + 1\\n\\n for j, tj in enumerate(t):\\n\\n if si == tj:\\n cost = 0\\n else:\\n cost = 1\\n\\n j1 = v1[j] + 1\\n j2 = v0[j + 1] + 1\\n j3 = v0[j] + cost\\n \\n if j1 < j2 and j1 < j3:\\n v1[j + 1] = j1\\n continue\\n \\n if j2 < j3:\\n v1[j+1] = j2\\n else:\\n v1[j+1] = j3\\n \\n v0 = v1.copy()\\n\\n if not asRatioOfMax:\\n return v1[len(t)]\\n\\n return 1 - v1[len(t)]/max([len(t), len(s)])\",\n \"def leveinshtein_distance(source,target):\\r\\n\\t#Step 1\\r\\n\\ts_len=len(source)\\r\\n\\tt_len=len(target)\\r\\n\\tcost=0\\r\\n\\tif(s_len==0):\\r\\n\\t\\treturn t_len\\r\\n\\tif(t_len==0):\\r\\n\\t\\treturn s_len\\r\\n\\tprint(\\\"Dimensions:\\\\n\\\\tN:%d\\\\n\\\\tM:%d\\\"%(s_len,t_len))\\r\\n\\t#Step 2\\r\\n\\tmatrix=[[0 for _ in range(0,t_len+1)] for _ in range(0, s_len+1)]\\r\\n\\t#Initialize first row 0..s_len\\r\\n\\tfor idx in range(0,s_len+1):\\r\\n\\t\\tmatrix[idx][0]=idx\\r\\n\\t#Initialize the first column 0..t_len\\r\\n\\tfor idx in range(0, t_len+1):\\r\\n\\t\\tmatrix[0][idx]=idx\\r\\n\\tprint(\\\"===Original===\\\")\\r\\n\\tprint_matrix(matrix,source,target)\\r\\n\\t#Step 3\\r\\n\\tfor i in range(1,s_len+1):\\r\\n\\t\\tch=source[i-1]\\r\\n\\t\\t#print(ch)\\r\\n\\t\\t#Step 4\\r\\n\\t\\tfor j in range(1,t_len+1):\\r\\n\\t\\t\\t#print(\\\">%s\\\"%target[j-1])\\r\\n\\t\\t\\t#Step 5\\r\\n\\t\\t\\tif ch==target[j-1]:\\r\\n\\t\\t\\t\\tcost=0\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tcost=1\\r\\n\\t\\t\\t#Step 6\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t#print(\\\"(i,j)=>(%d,%d)\\\"%(i,j))\\r\\n\\t\\t\\t#print(matrix[i][j])\\r\\n\\t\\t\\tmatrix[i][j]=minimum(\\r\\n\\t\\t\\t\\tmatrix[i-1][j]+1,\\r\\n\\t\\t\\t\\tmatrix[i][j-1]+1,\\r\\n\\t\\t\\t\\tmatrix[i-1][j-1]+cost\\r\\n\\t\\t\\t)\\r\\n\\tprint(\\\"===Final Matrix===\\\")\\r\\n\\tprint_matrix(matrix,source,target)\\r\\n\\treturn matrix[s_len-1][t_len-1]\",\n \"def matcher(features1, features2):\\n #TODO: write a matching function\\n #Performing the L2-Norm\\n new_features1=[]\\n new_features2=[]\\n for itr in range(5):\\n [rootOfSquare1,rootOfSquare2] = sumOfSquares(features1[itr],features2[itr])\\n new_features1.append(np.array(features1[itr])/rootOfSquare1)\\n new_features2.append(np.array(features2[itr])/rootOfSquare2)\\n indices = []\\n for itr in range(len(new_features1)):\\n findMinDist=[]\\n #findMaxCosineVal=[]\\n for itr2 in range(len(new_features2)):\\n f1 = new_features1[itr]\\n f2 = new_features2[itr2]\\n\\n #For evaluating the cosine similarity\\n # [rootOfSquare1,rootOfSquare2] = sumOfSquares(f1,f2)\\n # numerator = np.array(f1)*np.array(f2)\\n # numeratorSum = sum(numerator)\\n # denominator = rootOfSquare1*rootOfSquare2\\n # cosine = np.divide(numeratorSum,denominator)\\n # findMaxCosineVal.append(cosine)\\n\\n #For evaluating the similarity based on euclidean distance\\n Dist = np.array(f1) - np.array(f2)\\n sum=0\\n for i in Dist:\\n sum=sum+math.pow(i,2)\\n rootOfSum = math.sqrt(sum)\\n findMinDist.append(rootOfSum)\\n # print \\\"itr: \\\", itr, \\\" Matching scores: \\\", findMaxCosineVal\\n # bestMatch = findMaxCosineVal.index(max(findMaxCosineVal))\\n bestMatch = findMinDist.index(min(findMinDist))\\n indices.append([itr,bestMatch])\\n return indices\",\n \"def levenshtein_similarity(s1, s2, insert=None, delete=None, substitute=None,\\n insert_default=1, delete_default=1, substitute_default=1,\\n lower_bound=None):\\n insert = insert if isinstance(insert, dict) else {}\\n delete = delete if isinstance(delete, dict) else {}\\n substitute = substitute if isinstance(substitute, dict) else {}\\n\\n def compute_max_cost(s):\\n return sum([\\n max(\\n insert[c] if c in insert else insert_default,\\n delete[c] if c in delete else delete_default,\\n substitute[c] if c in substitute else substitute_default\\n ) for c in s\\n ])\\n\\n def estimate_min_char_cost(s):\\n return min([min(\\n insert[c] if c in insert else insert_default,\\n delete[c] if c in delete else delete_default,\\n substitute[c] if c in substitute else substitute_default\\n ) for c in s])\\n\\n utils.check_for_none(s1, s2)\\n utils.check_for_type(str, s1, s2)\\n\\n max_cost = max(compute_max_cost(s1), compute_max_cost(s2))\\n\\n if lower_bound:\\n diff = abs(len(s1) - len(s2))\\n if len(s1) == 0 and len(s2) == 0:\\n return 1.0\\n elif len(s1) == 0:\\n min_lev = float(diff * estimate_min_char_cost(s2))\\n elif len(s2) == 0:\\n min_lev = float(diff * estimate_min_char_cost(s1))\\n else:\\n min_lev = float(diff * min(estimate_min_char_cost(s1), estimate_min_char_cost(s2)))\\n est_sim = 1.0 - min_lev / max_cost\\n if est_sim < lower_bound:\\n return 0.0\\n\\n lev = levenshtein_distance(s1, s2, insert, delete, substitute,\\n insert_default, delete_default, substitute_default)\\n\\n if max_cost < lev:\\n raise ValueError('Illegal value of operation cost')\\n\\n if max_cost == 0:\\n return 1.0\\n\\n lev_sim = 1.0 - float(lev) / max_cost\\n if lower_bound and lev_sim < lower_bound:\\n return 0.0\\n return lev_sim\",\n \"def get_fuzz_ratio(first_word, second_word):\\n return fuzz.ratio(first_word, second_word), first_word, second_word\",\n \"def ratio(n1,n2, explain=0, optimize=False):\\n weight_normal_form = 5.0 #distance between soundexes of normal form\\n weight_normal_form_soundex = 8.0 #average distance between soundexes of normal form\\n weight_geslachtsnaam1 = 10.0 #distance between soundexes of geslachtsnamen\\n weight_geslachtsnaam2 = 10.0 #distance between geslachtsnaam\\n weight_initials = 2 #distance between initials\\n\\n nf1 = n1.guess_normal_form()\\n nf2 = n2.guess_normal_form()\\n\\n if not nf1 or not nf2:\\n return 0.0\\n elif nf1 == nf2:\\n return 1.0\\n ratio_normal_form = Similarity.average_distance(split(nf1), split(nf2))\\n \\n #create a simkplified soundex set for this name\\n #remove stopwords\\n# nf1 = remove_stopwords( nf1)\\n# nf2 = remove_stopwords( nf2)\\n \\n se1 = n1.get_normal_form_soundex()\\n se2 = n2.get_normal_form_soundex()\\n ratio_normal_form_soundex = Similarity.average_distance( se1, se2)\\n \\n #gelachtsnaam wordt op twee manieren met elkaar vergeleken\\n g1 = n1.geslachtsnaam() #or n1.get_volledige_naam()\\n g2 = n2.geslachtsnaam() #or n2.get_volledige_naam()\\n g1 = to_ascii(g1)\\n g2 = to_ascii(g2)\\n if not optimize:\\n #de soundexes van de achternaam worden meegewoen\\n #g1_soundex = n1.soundex_nl(g1, group=2, length=-1)\\n g1_soundex = n1.geslachtsnaam_soundex()\\n #g2_soundex = n2.soundex_nl(g2, group=2, length=-1)\\n g2_soundex = n2.geslachtsnaam_soundex()\\n ratio_geslachtsnaam1 = Similarity.average_distance(g1_soundex, g2_soundex)\\n else:\\n ratio_geslachtsnaam1 = 1 \\n weight_geslachtsnaam1 = 0\\n \\n #n de afstand van de woorden in de achtenraam zelf\\n ratio_geslachtsnaam2 = Similarity.average_distance(\\n re.split('[ \\\\.\\\\,\\\\-]', g1.lower()),\\n re.split('[ \\\\.\\\\,\\\\-]', g2.lower()),\\n levenshtein_ratio)\\n n1_initials = n1.initials()\\n n1_initials_lower = n1_initials.lower()\\n n2_initials = n2.initials()\\n n2_initials_lower = n2_initials.lower()\\n n1_contains_initials = n1.contains_initials()\\n n2_contains_initials = n2.contains_initials()\\n #count initials only if we have more than one\\n #(or perhaps make this: if we know the first name)\\n if len(n1_initials) == 1 or len(n2_initials) == 1:\\n #initials count much less if there is only one\\n weight_initials = weight_initials_if_one_name_consists_of_one_word_only\\n# ratio_initials = .5\\n ratio_initials = levenshtein_ratio(n1_initials_lower, n2_initials_lower)\\n elif n1_contains_initials or n2_contains_initials:\\n ratio_initials = levenshtein_ratio(n1_initials_lower, n2_initials_lower)\\n weight_initials = weight_initials_if_one_name_is_in_initials\\n elif len(n1_initials) > 1 and len(n2_initials) > 1:\\n ratio_initials = levenshtein_ratio(n1_initials_lower, n2_initials_lower)\\n else:\\n ratio_initials = 0.7\\n \\n if n1_contains_initials or n2_contains_initials:\\n weight_normal_form = weight_normal_form_if_one_name_is_in_initials \\n weight_normal_form_soundex = weight_normal_form_soundex_if_one_name_is_in_initials\\n\\n counter = (ratio_normal_form * weight_normal_form +\\n ratio_normal_form_soundex * weight_normal_form_soundex +\\n ratio_geslachtsnaam1 * weight_geslachtsnaam1 +\\n ratio_geslachtsnaam2 * weight_geslachtsnaam2 +\\n ratio_initials * weight_initials)\\n numerator = (weight_normal_form + weight_normal_form_soundex +\\n weight_initials + weight_geslachtsnaam1 + weight_geslachtsnaam2)\\n if numerator == 0:\\n return 0.0\\n final_ratio = counter/numerator\\n\\n if explain:\\n s = '-' * 100 + '\\\\n'\\n s += 'Naam1: %s [%s] [%s] %s\\\\n' % (n1, n1_initials, n1.guess_normal_form(), se1)\\n s += 'Naam2: %s [%s] [%s] %s\\\\n' % (n2, n2_initials, n2.guess_normal_form(), se2)\\n s += 'Similarity ratio: %s\\\\n' % final_ratio\\n s += '--- REASONS' + '-' * 30 + '\\\\n'\\n format_s = '%-30s | %-10s | %-10s | %-10s | %-10s | %s-10s\\\\n'\\n s += format_s % ('\\\\t property', ' ratio', ' weight','relative_weight', ' r*w', 'r * relative_w')\\n s += '\\\\t' + '-' * 100 + '\\\\n'\\n format_s = '\\\\t%-30s | %-10f | %-10f | %-10f | %-10f | %-10f\\\\n'\\n s += format_s % (' normal_form', ratio_normal_form, weight_normal_form,weight_normal_form/counter, ratio_normal_form * weight_normal_form, ratio_normal_form * weight_normal_form/counter)\\n s += format_s % ('soundex van normal_form', ratio_normal_form_soundex, weight_normal_form_soundex,weight_normal_form_soundex/counter, ratio_normal_form_soundex* weight_normal_form_soundex, ratio_normal_form_soundex * weight_normal_form_soundex/counter)\\n s += format_s % ('soundex van geslachtsnaam1', ratio_geslachtsnaam1, weight_geslachtsnaam1,weight_geslachtsnaam1/counter, ratio_geslachtsnaam1 * weight_geslachtsnaam1, ratio_geslachtsnaam1 * weight_geslachtsnaam1/counter)\\n s += format_s % ('geslachtsnaam', ratio_geslachtsnaam2, weight_geslachtsnaam2,weight_geslachtsnaam2/counter, ratio_geslachtsnaam2 *weight_geslachtsnaam2 , ratio_geslachtsnaam2 * weight_geslachtsnaam2/counter)\\n s += format_s % ('initials', ratio_initials, weight_initials, weight_initials/counter, ratio_initials *weight_initials, ratio_initials * weight_initials/counter)\\n s += '\\\\tTOTAL (numerator) | %s (counter = %s)\\\\n' % (counter, numerator)\\n \\n return s\\n return final_ratio\",\n \"def edit_distance(str1, str2):\\r\\n pass\",\n \"def fuzzy_token_sort_ratio(thing_1, thing_2):\\n return fuzz.token_sort_ratio(thing_1, thing_2)\",\n \"def Path_Similarity(word1, word2):\\n\\n # Initial test to confirm unique nouns, otherwise passes back 1\\n\\n if word1 == word2:\\n return 1, word1\\n\\n # Sets up Initial Variables & Dictionaries\\n\\n stepup1 = [word1]\\n stepup2 = [word2]\\n dict1= {}\\n dict2= {}\\n currentstep1 = []\\n currentstep2 = []\\n\\n # Iterates through a loop an arbitrary # of times, adding new hypernyms\\n # for each word to individual dictionaries with the number of iterations\\n # as the key to the dictionary. The two dictionaries are saved perpetually\\n\\n for la in range(50):\\n for i in range(len(stepup1)):\\n currentstep1 += (stepup1[i].hypernyms())\\n for syn in stepup1:\\n dict1[syn] = la\\n for i in range(len(stepup2)):\\n currentstep2 = (stepup2[i].hypernyms())\\n for syn in stepup2:\\n dict2[syn] = la\\n\\n # Variables are reset and converted to continue the next stage of the loop\\n\\n stepup1 = currentstep1\\n stepup2 = currentstep2\\n currentstep1 = []\\n currentstep2 = []\\n\\n\\n # Each loop the dictionaries are checked for matches. I have confirmed that\\n # checking each cycle is faster than checking at the end of an arbitrary\\n # number of cycles.\\n\\n # Removes applied words as Possible Subsumers Per Fridays Clas\\n dict1.pop(word1)\\n dict2.pop(word2)\\n\\n #Gets possible Least Common Subsumers\\n dict1Set = set(dict1)\\n dict2Set = set(dict2)\\n d = {}\\n for name in dict1Set.intersection(dict2Set):\\n d[name] = dict1[name]\\n pos_lcs = [key for min_value in (min(d.values()),) for key in d if d[key] == min_value]\\n\\n #Returns Actual LCS\\n key_lcs = []\\n for i in pos_lcs:\\n key_lcs.append(shortestPath(wn.synset('entity.n.01'),i))\\n lcs = (pos_lcs[key_lcs.index(max(key_lcs))])\\n\\n #Returns path Similarity Value and Synset of LCS; Must Error Proof\\n\\n return 1/(dict1[lcs] + dict2[lcs]), lcs\",\n \"def compare_str(seq1, seq2):\\n if seq1 == seq2:\\n return 1\\n ld = Levenshtein.distance(seq1, seq2)\\n longest = len(seq1 if len(seq1) > len(seq2) else seq2)\\n return (longest - ld) / longest\",\n \"def wer(self, s1, s2):\\n\\n # build mapping of words to integers\\n b = set(s1.split() + s2.split())\\n word2char = dict(zip(b, range(len(b))))\\n\\n # map the words to a char array (Levenshtein packages only accepts\\n # strings)\\n w1 = [chr(word2char[w]) for w in s1.split()]\\n w2 = [chr(word2char[w]) for w in s2.split()]\\n\\n return Lev.distance(''.join(w1), ''.join(w2))\",\n \"def calculate_score(s1, s2, l1, l2, startpoint):\\n\\n matched = \\\"\\\" # to hold string displaying alignments\\n score = 0\\n for i in range(l2):\\n if (i + startpoint) < l1:\\n if s1[i + startpoint] == s2[i]: # if the bases match\\n matched = matched + \\\"*\\\" # * indicates a match\\n score = score + 1\\n else:\\n matched = matched + \\\"-\\\" # - indicates no match\\n\\n return score\",\n \"def score_match(first_string, second_string, domain_score=False):\\n score = 0\\n\\n if first_string == second_string:\\n return SCORE_THRESHOLD_NORMAL\\n\\n if domain_score:\\n if remove_tld(first_string) == remove_tld(second_string):\\n return SCORE_THRESHOLD_NORMAL\\n\\n if second_string in first_string:\\n return SCORE_THRESHOLD_NORMAL\\n\\n if domain_score:\\n first_string = remove_tld(first_string)\\n second_string = remove_tld(second_string)\\n\\n l_distance = Levenshtein.distance(first_string, second_string)\\n fuzz_ratio = fuzz.token_sort_ratio(first_string, second_string)\\n\\n if l_distance <= 2:\\n score = 50 + 25 * (2 - l_distance)\\n\\n elif fuzz_ratio > 80:\\n score = fuzz_ratio - 25\\n\\n first_len = len(first_string)\\n second_len = len(second_string)\\n\\n if first_len > second_len / 2 and first_len > 4:\\n score += fuzzy_score_string(first_string, second_string)\\n\\n return score\",\n \"def _pairwise_dist(self,seq1,seq2):\\n \\n return jf.damerau_levenshtein_distance(str(seq1), str(seq2))\",\n \"def optimal_string_alignment_similarity(s1, s2):\\n max_cost = max(len(s1), len(s2))\\n\\n if max_cost == 0:\\n return 1.0\\n\\n return 1.0 - float(optimal_string_alignment_distance(s1, s2)) / max_cost\",\n \"def needle_diff(left_struc, right_struc, key, minimal=True):\\n if type(left_struc) not in (list, tuple):\\n return keyset_diff(left_struc, right_struc, key, minimal)\\n assert type(right_struc) in (list, tuple)\\n\\n down_col = 0\\n lastrow = [\\n [[key + [sub_i]] for sub_i in range(i)]\\n for i in range(len(left_struc), -1, -1)\\n ]\\n\\n def modify_cand():\\n \\\"\\\"\\\"Build the candidate diff that involves (potentially) modifying an\\n element.\\\"\\\"\\\"\\n if col_i + 1 < len(lastrow):\\n return (lastrow[col_i + 1] +\\n diff(left_elem, right_elem, key=key + [left_i],\\n minimal=minimal, verbose=False))\\n\\n def delete_cand():\\n \\\"\\\"\\\"Build the candidate diff that involves deleting an element.\\\"\\\"\\\"\\n if row:\\n return row[0] + [[key + [left_i]]]\\n\\n def append_cand():\\n \\\"\\\"\\\"Build the candidate diff that involves appending an element.\\\"\\\"\\\"\\n if col_i == down_col:\\n return (lastrow[col_i] +\\n [[key + [append_key(lastrow[col_i], left_struc, key)],\\n right_elem]])\\n\\n for right_i, right_elem in enumerate(right_struc):\\n first_left_i = min(right_i, len(left_struc) - 1)\\n left_elems = left_struc[first_left_i:]\\n row = []\\n\\n for left_i, left_elem in enumerate(left_elems, first_left_i):\\n col_i = len(left_struc) - left_i - 1\\n cands = [c for c in (modify_cand(), delete_cand(), append_cand())\\n if c is not None]\\n winner = min(cands, key=lambda d: len(compact_json_dumps(d)))\\n row.insert(0, winner)\\n\\n lastrow = row\\n return winner\",\n \"def fuzzy_matching(mapper, fav_product, verbose=True):\\n match_tuple = []\\n # get match\\n for title, idx in mapper.items():\\n ratio = fuzz.ratio(title.lower(), fav_product.lower())\\n if ratio >= 60:\\n match_tuple.append((title, idx, ratio))\\n # sort\\n match_tuple = sorted(match_tuple, key=lambda x: x[2])[::-1]\\n if not match_tuple:\\n print('Oops! No match is found')\\n return\\n # if verbose:\\n # print('Found possible matches in our database: {0}\\\\n'.format([x[0] for x in match_tuple]))\\n return match_tuple[0][1]\",\n \"def similar_text(word1, word2) -> float:\\n\\n return textdistance.overlap.similarity(word1, word2)\",\n \"def compute_backpointers(s0, s1): #Tillverkar en array med backpointrs\\r\\n if s0 == None or s1 == None:\\r\\n raise Exception('Both s0 and s1 have to be set')\\r\\n rows = len(s0)+1 # antalet rader\\r\\n columns = len(s1)+1 # antalet kolumner\\r\\n\\r\\n ####### Tillverkar Levenshtein matrisen ########\\r\\n # Gör en tom matris med nollor\\r\\n distance = [[0 for y in range(len(s1)+1)] for x in range(len(s0)+1)]\\r\\n\\r\\n # Gör de yttre lagrerna i matrisen 0 -> len(str) vertikalt och horisontellt\\r\\n for i in range(1,rows):\\r\\n distance[i][0] = i\\r\\n for i in range(1,columns):\\r\\n distance[0][i] = i\\r\\n\\r\\n # Beräknar kostnaderna för varje plats inne i matrisen och sätter in dem\\r\\n # kollar om bokstaven på indexet i de två orden är samma i sådana fall kostar det 0\\r\\n # och skall ha samma värde som diagonalt innan, annars kostar det 1 från över eller underself.\\r\\n for column in range(1,columns):\\r\\n for row in range(1,rows): # kolla varje rad i vare column\\r\\n if s0[row-1] == s1[column -1]: # om det är samma bokstav kostar det 0\\r\\n c = 0\\r\\n else: # annars kostar det 2\\r\\n c = 2\\r\\n distance[row][column] = min(distance[row-1][column] + 1,distance[row][column-1] + 1,distance[row-1][column-1] + c)\\r\\n # raden över säger att det minsta värdet av över eller bredvid + 1 eller diagonalt innan plus (0 eller 2)\\r\\n # skall sättas in på platsen i matrisen.\\r\\n\\r\\n # det minsta avståndet är\\r\\n cost = distance[row][column]\\r\\n print(\\\"totalkostnaden är\\\")\\r\\n print(cost)\\r\\n\\r\\n\\r\\n ####### Tillverkar backptr-matrisen ########\\r\\n # Tillverkar en tom matris med [0,0] för till backptr-matrisen\\r\\n backptr = [[[0, 0] for y in range(len(s1)+1)] for x in range(len(s0)+1)]\\r\\n\\r\\n # går igenom platserna i Levenshtein matrisen bakirfrån\\r\\n for column in range(columns-1,0,-1):\\r\\n for row in range(rows-1,0,-1):\\r\\n # Om värdet till vänster är det minsta: peka vänster\\r\\n if distance[row][column-1] == min(distance[row-1][column-1],distance[row][column-1],distance[row-1][column]):\\r\\n backptr[row][column][0] = row\\r\\n backptr[row][column][1] = column -1\\r\\n # Om värdet över är det minsta: peka upp\\r\\n if distance[row-1][column] == min(distance[row-1][column-1],distance[row][column-1],distance[row-1][column]):\\r\\n backptr[row][column][0] = row -1\\r\\n backptr[row][column][1] = column\\r\\n # om värdet diagonalt är minst: peka på diagonalt\\r\\n if distance[row-1][column-1] == min(distance[row-1][column-1],distance[row][column-1],distance[row-1][column]):\\r\\n backptr[row][column][0] = row-1\\r\\n backptr[row][column][1] = column -1\\r\\n\\r\\n # Gör yttervärdena i matrisen, (OBS behövs ej)\\r\\n for i in range(0,rows):\\r\\n j = i-1\\r\\n backptr[i][0][0] = j\\r\\n backptr[i][0][1] = 0\\r\\n for i in range(0,columns):\\r\\n j = i-1\\r\\n backptr[0][i][1] = j\\r\\n backptr[0][i][0] = 0\\r\\n\\r\\n return backptr\",\n \"def shortestPath(haystack, needle):\\n if needle == haystack:\\n return 0\\n hyponyms = haystack.hyponyms()\\n if len(hyponyms) > 0:\\n return 1 + min([shortestPath(hypo, needle) for hypo in hyponyms])\\n else:\\n return 1000\",\n \"def Extended_Lesk(word1,word2):\\n\\n #Creates a list of the word, and one layer of hyponyms\\n list1 = [word1]\\n for i in word1.hyponyms():\\n list1.append(i)\\n list2 = [word2]\\n for i in word2.hyponyms():\\n list2.append(i)\\n\\n #Creates a list of each of the above words' definitions, tokenized\\n words1 = []\\n words2 = []\\n for i in list1:\\n words1.append([l for l in word_tokenize(i.definition())])\\n for i in list2:\\n words2.append([l for l in word_tokenize(i.definition())])\\n\\n #Calculates the Maximum length of the Longest Definition\\n lengths = []\\n lengths.extend(len(l) for l in words1)\\n lengths.extend(len(l) for l in words2)\\n maxim = max(lengths)\\n\\n igramcount = []\\n igram1 = []\\n igram2 = []\\n\\n # Creates N-grams for each definition for each N, from 1:max(lengths)\\n for i in range(int(maxim)):\\n for g in words1:\\n for l in ngrams(g, i+1):\\n igram1.append(l)\\n for f in words2:\\n for m in ngrams(f, i+1):\\n igram2.append(m)\\n\\n #For Each N-gram in the first set, which matches that of the Second set,\\n # Denoting a form of \\\"Similarity\\\" between the two definitions,\\n # Record the Value of N into a new List, igramcount.\\n for x in set(igram1):\\n if x in set(igram2):\\n igramcount.append(i + 1)\\n\\n igram1 = []\\n igram2 = []\\n\\n #Square the values of igramcount, and return the sum as the value of Extended Lesk.\\n squared = [number**2 for number in igramcount]\\n return sum(squared)\",\n \"def fuzzy_equals(a, b):\\n epsilon = 10**(-6) \\n return (abs(a - b) < epsilon)\",\n \"def min_dist_solution(self, words, keyword_dict = None):\\r\\n\\r\\n\\t\\t# default settings\\r\\n\\t\\tif keyword_dict == None:\\r\\n\\t\\t\\tkeyword_dict = self.keyword_dict\\r\\n\\r\\n\\t\\tindexed_text = list(enumerate(words))\\r\\n\\t\\t# all found keyword positions\\r\\n\\t\\tkeyword_pos = []\\r\\n\\t\\tkw_counts = [(len(kw.split()),kw) for kw in keyword_dict]\\r\\n\\t\\tkw_length_set = set((l[0] for l in kw_counts))\\r\\n\\t\\t\\r\\n\\t\\t# seperate keywords by their length\\r\\n\\t\\tfor length in kw_length_set:\\r\\n\\t\\t\\tkw_lgram = ngrams(indexed_text, length)\\r\\n\\t\\t\\t# start, end, ngram token\\r\\n\\t\\t\\tkw_lgram_text = [(g[0][0],g[-1][0],' '.join([token[1] for token in g])) \\r\\n\\t\\t\\t\\t\\t\\t\\t for g in kw_lgram]\\r\\n\\t\\t\\tfixed_length_kw = [kw[1] for kw in kw_counts if kw[0] == length]\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tfixed_keyword_pos = [(kw_s,kw_e,token) for kw_s,kw_e,token in kw_lgram_text\\r\\n\\t\\t\\t \\t\\t\\t\\t\\t if token in fixed_length_kw]\\r\\n\\t\\t\\tkeyword_pos += fixed_keyword_pos\\r\\n\\t\\t# all found distances\\r\\n\\t\\tdistances = []\\r\\n\\t\\tfor kw_s,kw_e,kw in keyword_pos:\\r\\n\\t\\t\\tdistance = keyword_dict[kw]['distance']\\r\\n\\t\\t\\t# TODO handle case when value we search for is consisted of multiple words\\r\\n\\t\\t\\tregex_pattern = keyword_dict[kw]['regex']\\r\\n\\t\\t\\tsearch_direction = keyword_dict[kw]['search_direction']\\r\\n\\t\\t\\t# start of the block\\r\\n\\t\\t\\tstart = kw_s - distance if kw_s-distance > 0 else 0\\r\\n\\t\\t\\t# end of the block\\r\\n\\t\\t\\tend = kw_e + distance\\r\\n\\t\\t\\tif search_direction == 'right':\\r\\n\\t\\t\\t\\tsearchable_block = indexed_text[kw_e:end]\\r\\n\\t\\t\\telif search_direction == 'left':\\r\\n\\t\\t\\t\\tsearchable_block = indexed_text[start:kw_s]\\r\\n\\t\\t\\telif search_direction == 'both':\\r\\n\\t\\t\\t\\tsearchable_block = indexed_text[start:end]\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\t# mb hanlde search_direction value\\r\\n\\t\\t\\t\\tsearchable_block = []\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tvalue_pos = [index for index,value in searchable_block\\r\\n\\t\\t\\t\\t\\t\\t if re.search(regex_pattern,value)]\\r\\n\\t\\t\\tdistance = [(self.dist(vp,kw_s,kw_e),vp,kw) for vp in value_pos]\\r\\n\\r\\n\\t\\t\\tdistances += distance\\r\\n\\t\\tif len(distances) == 0:\\r\\n\\t\\t\\treturn ('not found', None,'no kw')\\r\\n\\t\\telse:\\r\\n\\t\\t\\tmin_distance,found_target_pos,kw = min(distances)\\r\\n\\t\\t\\treturn words[found_target_pos],found_target_pos,kw\",\n \"def edit_distance(wordA, wordB):\\n if not isinstance(wordA,list):\\n lettersA = tamil.utf8.get_letters(wordA)\\n else:\\n lettersA = wordA\\n\\n if not isinstance(wordB,list):\\n lettersB = tamil.utf8.get_letters(wordB)\\n else:\\n lettersB = wordB\\n n_A = len(lettersA)\\n n_B = len(lettersB)\\n dist_AB = [[0 for i in range(0, n_B + 1)] for i in range(0, (n_A + 1))]\\n # Target prefix reached by insertion\\n for j in range(1, n_B + 1):\\n dist_AB[0][j] = j\\n for i in range(1, n_A + 1):\\n dist_AB[i][0] = i\\n for j in range(1, n_B + 1):\\n for i in range(1, n_A + 1):\\n if lettersA[i - 1] == lettersB[j - 1]:\\n new_dist = dist_AB[i - 1][j - 1]\\n else:\\n new_dist = min(\\n [\\n dist_AB[i - 1][j] + 1,\\n dist_AB[i][j - 1] + 1,\\n dist_AB[i - 1][j - 1] + 1,\\n ]\\n ) # del, ins, or sub\\n dist_AB[i][j] = new_dist\\n return dist_AB[-1][-1]\",\n \"def distance_between_pattern_and_strings(pattern, dna):\\n\\n k = len(pattern)\\n distance = 0\\n\\n for text in dna:\\n hamming_distance = 1000000\\n for i in range(len(text) - k + 1):\\n if hamming_distance > compute_hamming_distance(pattern, text[i:i + k]):\\n hamming_distance = compute_hamming_distance(pattern, text[i:i + k])\\n distance = distance + hamming_distance\\n return distance\",\n \"def compare_tokenized(repairmsg, targetmsg):\\n nearest = -1\\n\\n # Cartesian product of tokens in either msg\\n token_pairs = product(repairmsg.tokenized(), targetmsg.tokenized())\\n\\n # Reduce to unique pairs of inequivalent tokens\\n # This used to change order of r and t but now we keep them...\\n tokens = list(set((r, t)# if r < t else (t, r)\\n for r, t in token_pairs\\n if r != t))\\n\\n # Get minimum positive dist (distances <0 are edit distances above the\\n # short-circuit threshold of our Levenshtein distance function).\\n distances = [compare_token(r, t) for r, t in tokens]\\n\\n outputs = [(repair, target, dist)\\n for ((repair, target), dist) in zip(tokens, distances)\\n if dist > 0]\\n if not outputs:\\n return -1\\n\\n # min() will return the tuple with lowest dist\\n repair, target, dist = min(outputs, key=lambda tup: tup[2]) # [2] is dist\\n return repair, target, dist\",\n \"def suggest(word, cutoff=0.77):\\n if word in LOOKUP_TABLE:\\n return LOOKUP_TABLE[word]\\n\\n guess = difflib.get_close_matches(word, MOST_COMMON_DOMAINS, n=1, cutoff=cutoff)\\n if guess and len(guess) > 0:\\n return guess[0]\\n return word\",\n \"def compare_junctions(\\n r1: BioReaders.GMAPSAMRecord,\\n r2: BioReaders.GMAPSAMRecord,\\n internal_fuzzy_max_dist: int = 0,\\n max_5_diff: int = 999999,\\n max_3_diff: int = 999999,\\n) -> str:\\n # assert internal_fuzzy_max_dist >= 0\\n # assert max_5_diff >= 0\\n # assert max_3_diff >= 0\\n strand = r1.strand\\n found_overlap = False\\n # super/partial --- i > 0, j = 0\\n # exact/partial --- i = 0, j = 0\\n # subset/partial --- i = 0, j > 0\\n for i, x in enumerate(r1.segments):\\n # find the first matching r2, which could be further downstream\\n for j, y in enumerate(r2.segments):\\n if i > 0 and j > 0:\\n break\\n if overlaps(x, y) > 0:\\n found_overlap = True\\n break\\n if found_overlap:\\n break\\n if not found_overlap:\\n return \\\"nomatch\\\"\\n # now we have r1[i] matched to r2[j]\\n # check that r1[i] and r2[j] match within 5'/3' max diff\\n if strand == \\\"+\\\":\\n if (\\n abs(r1.segments[i].start - r2.segments[j].start) > max_5_diff\\n or abs(r1.segments[i].end - r2.segments[j].end) > max_3_diff\\n ):\\n return \\\"partial\\\"\\n else:\\n if (\\n abs(r1.segments[i].start - r2.segments[j].start) > max_3_diff\\n or abs(r1.segments[i].end - r2.segments[j].end) > max_5_diff\\n ):\\n return \\\"partial\\\"\\n\\n # if just one exon, then must have less than 5'/3' diff\\n # pdb.set_trace()\\n\\n if len(r1.segments) == 1:\\n if len(r2.segments) == 1:\\n # if both are single-exon, check that they have less than 5'/3' diff\\n if (\\n abs(r1.segments[0].start - r2.segments[0].start) <= max_5_diff\\n and abs(r1.segments[0].end - r2.segments[0].end) <= max_3_diff\\n ):\\n return \\\"exact\\\"\\n else:\\n return \\\"partial\\\"\\n else:\\n # case: r1 single exon, r2 multi-exon\\n # check that the matching exon is within difference\\n # and that the r1 exon does NOT overlap with previous or later exons in r2\\n if (\\n abs(r1.segments[0].end - r2.segments[j].end) <= max_3_diff\\n and abs(r1.segments[0].start - r2.segments[j].start) <= max_5_diff\\n and (\\n (j == 0 and r1.segments[0].end < r2.segments[1].start)\\n or (\\n j >= 1\\n and r1.segments[0].start > r2.segments[j - 1].end\\n and (\\n j == len(r2.segments) - 1\\n or r1.segments[0].end < r2.segments[j + 1].start\\n )\\n )\\n )\\n ):\\n return \\\"subset\\\"\\n else:\\n return \\\"partial\\\"\\n else:\\n if len(r2.segments) == 1:\\n # case: r1 multi exon, r2 single exon\\n # r1.segments[i] matches r2.segments[0]\\n # need to check that the r2, being single exon, did not overlap with previous or later r1 exons\\n # and also the matching r1, r2 exon does not have huge 5'/3' difference\\n if (\\n (i == 0 or r1.segments[i - 1].end < r2.segments[0].start)\\n and (\\n i == len(r1.segments) - 1\\n or r1.segments[i].start > r2.segments[0].end\\n )\\n and (abs(r1.segments[i].start - r2.segments[0].start) <= max_5_diff)\\n and (abs(r1.segments[i].end - r2.segments[0].end) <= max_3_diff)\\n ):\\n return \\\"super\\\"\\n else:\\n return \\\"partial\\\"\\n else: # both r1 and r2 are multi-exon, check that all remaining junctions agree\\n k = 0\\n while i + k + 1 < len(r1.segments) and j + k + 1 < len(r2.segments):\\n if (\\n abs(r1.segments[i + k].end - r2.segments[j + k].end)\\n > internal_fuzzy_max_dist\\n or abs(r1.segments[i + k + 1].start - r2.segments[j + k + 1].start)\\n > internal_fuzzy_max_dist\\n ):\\n return \\\"partial\\\"\\n k += 1\\n # print i, j, k\\n # check that the last matching exon, the ends are with max 5'/3' diff\\n if strand == \\\"+\\\":\\n if abs(r1.segments[i + k].end - r2.segments[j + k].end) > max_3_diff:\\n return \\\"partial\\\"\\n else:\\n if abs(r1.segments[i + k].end - r2.segments[j + k].end) > max_5_diff:\\n return \\\"partial\\\"\\n\\n if i + k + 1 == len(r1.segments):\\n if j + k + 1 == len(r2.segments):\\n if i == 0:\\n if j == 0:\\n return \\\"exact\\\"\\n else:\\n return \\\"subset\\\" # j > 0\\n else:\\n return \\\"super\\\"\\n else: # r1 is at end, r2 not at end\\n if i == 0:\\n return \\\"subset\\\"\\n else: # i > 0\\n if (\\n abs(r1.segments[i + k - 1].end - r2.segments[j + k - 1].end)\\n > internal_fuzzy_max_dist\\n or abs(r1.segments[i + k].start - r2.segments[j + k].start)\\n > internal_fuzzy_max_dist\\n ):\\n return \\\"partial\\\"\\n else:\\n return \\\"concordant\\\"\\n else: # r1 not at end, r2 must be at end\\n if j == 0:\\n return \\\"super\\\"\\n else:\\n if (\\n abs(r1.segments[i + k - 1].end - r2.segments[j + k - 1].end)\\n > internal_fuzzy_max_dist\\n or abs(r1.segments[i + k].start - r2.segments[j + k].start)\\n > internal_fuzzy_max_dist\\n ):\\n return \\\"partial\\\"\\n else:\\n return \\\"concordant\\\"\",\n \"def similar_string_fast(first_string, second_string):\\n partial_score = fuzz.ratio(first_string, second_string)\\n token_score = fuzz.token_set_ratio(first_string, second_string)\\n\\n if max(partial_score, token_score) >= SCORE_THRESHOLD_FAST:\\n return True\\n\\n return False\",\n \"def edit_distance(str1, str2):\\n\\n if not str1:\\n return len(str2)\\n if not str2:\\n return len(str1)\\n\\n DP = [[-1 for __ in str2] for ___ in str1]\\n DP[0][0] = 0 if str1[0] == str2[0] else 1\\n\\n\\n for x, let1 in enumerate(str1):\\n startat = 0\\n if x == 0:\\n startat = 1\\n for y, let2 in enumerate(str2[startat:], startat):\\n minimum = float('inf')\\n if x != 0:\\n minimum = min(DP[x-1][y] + 1, minimum)\\n if y != 0:\\n minimum = min(DP[x-1][y-1] + (0 if let1 == let2 else 1), minimum)\\n if y != 0:\\n minimum = min(DP[x][y-1] + 1, minimum)\\n\\n DP[x][y] = minimum\\n\\n return DP[len(str1) - 1][len(str2) - 1]\",\n \"def GetSuggesteeSimilarity(suggestee1_tags, suggestee2_tags):\\n total_size = len(suggestee1_tags) + len(suggestee2_tags)\\n if total_size == 0:\\n return 1.\\n size_of_intersection = 0\\n elems_in_first = {}\\n for tag in suggestee1_tags:\\n elems_in_first[tag] = True\\n for tag in suggestee2_tags:\\n if tag in elems_in_first:\\n size_of_intersection += 1\\n return size_of_intersection / (total_size - size_of_intersection)\",\n \"def test_multiple_word(self):\\n score = location.match_weight('weston super mare UK', ['weston super mare'])\\n\\n self.assertEqual(score, 1000)\",\n \"def add_substring_match_features(self,lst1,lst2,normalize_factor = 1.):\\n for i in range(self.RE_LOW,self.RE_HI+1):\\n for j in range(self.WILD_LOW,self.WILD_HI+1):\\n self.features.append(Measures.longest_substring_with_wildcards(lst1, lst2, i, j) / normalize_factor)\",\n \"def getSuggestions(self, query): # a suggestions method for all the suggestions\\r\\n\\r\\n \\r\\n suggestions =[] # a new list to add all the suggested words\\r\\n\\r\\n j = len(query) # find length of the query \\r\\n list_of_req_strings = [i for i in self._languageSet if len(i) in ( j -1, j, j+ 1)] # a list for required strings with equal lenth of query\\r\\n # and words with length of query +1 and -1\\r\\n\\r\\n \\r\\n for word in list_of_req_strings: # a for loop to check all the saved strings with query\\r\\n if query == word: # if query is a legitimate word (equal to word in list)\\r\\n suggestions.append(word) # add it to the suggestions\\r\\n n = len(word) # find the length of each word\\r\\n match_Count = 0 # keep the count of matched letters\\r\\n for i in range(j): # a for loop with range of length of query\\r\\n if query[0].isupper(): # check if the first letter is upper case letter\\r\\n query, word = query.capitalize(), word.capitalize() # capitalize query and each word if query's first letter is a upper case letter\\r\\n if query[i] in word: # then check each letter of query in word\\r\\n match_Count += 1 # increase the macth count if matches\\r\\n else: # if first letter of query is not an upper case letter\\r\\n query, word = query.lower(), word.lower() # change query and each word to lower case\\r\\n if query[i] in word: # then check each letter of query in word\\r\\n match_Count += 1 # increase the macth count if matches\\r\\n\\r\\n if match_Count == (max(j, n) - 1): # compare the match count with the max letter string of query and word\\r\\n suggestions.append(word) # add the word if it is one edit distance\\r\\n if match_Count == len(word)+1: # if match count is one value more than the word\\r\\n if not word in suggestions: # if the word not in suggestions\\r\\n suggestions.append(word) # add the word to the suggestions list\\r\\n\\r\\n\\r\\n for k in range(j - 1): # a for loop with range of query length -1\\r\\n inverted_char_word = query[:k]+query[k+1]+query[k]+query[(k+2):] # check by changing two letters(neighbering letters) till last letter\\r\\n if inverted_char_word not in suggestions: # if the changed word not in suggestions\\r\\n if inverted_char_word in list_of_req_strings: # and in list_req_strings\\r\\n suggestions.append(inverted_char_word) # add the changed word to the suggestions\\r\\n\\r\\n return (sorted(suggestions)) # return the sorted suggestions list\\r\",\n \"def string_edit_dist(str1, str2):\\n sm = edit_distance.SequenceMatcher(a=str1, b=str2)\\n return sm.distance()\",\n \"def test_jaro_winkler():\\n assert textdistance.jaro_winkler(\\\"campell\\\", \\\"campbell\\\") == pytest.approx(0.9792, abs=0.01)\\n assert textdistance.jaro_winkler(\\\"shakelford\\\", \\\"shakleford\\\") == pytest.approx(0.9848, abs=0.01)\\n assert textdistance.jaro_winkler(\\\"dwayne\\\", \\\"duane\\\") == pytest.approx(0.84, abs=0.01)\",\n \"def levenshtein_distance(s: Union[bytes, str], t: Union[bytes, str]) -> int:\\n if s is None or t is None:\\n raise ValueError(\\\"Strings must not be None\\\")\\n\\n n = len(s)\\n m = len(t)\\n\\n if n == 0:\\n return m\\n elif m == 0:\\n return n\\n\\n if n > m:\\n tmp = s\\n s = t\\n t = tmp\\n n = m\\n m = len(t)\\n\\n p = [0] * (n + 1)\\n d = [0] * (n + 1)\\n\\n for i in range(0, n + 1):\\n p[i] = i\\n\\n for j in range(1, m + 1):\\n if DEBUG_DISTANCE:\\n if j % 100 == 0:\\n print(\\\"DEBUG:\\\", int(j / (m + 1.0) * 100), \\\"%\\\\r\\\", end=' ', file=sys.stderr)\\n t_j = t[j - 1]\\n d[0] = j\\n\\n for i in range(1, n + 1):\\n cost = 0 if s[i - 1] == t_j else 1\\n # minimum of cell to the left+1, to the top+1, diagonally left and up +cost\\n d[i] = min(min(d[i - 1] + 1, p[i] + 1), p[i - 1] + cost)\\n\\n _d = p\\n p = d\\n d = _d\\n\\n if DEBUG_DISTANCE:\\n print(\\\"\\\\n\\\", file=sys.stderr)\\n return p[n]\",\n \"def needleman_wunsch(\\n seq1, seq2, match=1, mismatch=-1, gap_open=-5, gap_extend=-3, at_genome_start=False\\n):\\n alignments = pairwise2.align.globalms(\\n seq1,\\n seq2,\\n match,\\n mismatch,\\n gap_open,\\n gap_extend,\\n )\\n # Alignments is a list of tuples. Each tuple has length 5. Entries:\\n # 0: seq1 alignment (ie with dashes for indels)\\n # 1: seq2 alignemnt\\n # 2: alignment score\\n # 4, 5: don't know (not using them)\\n if len(alignments) == 1:\\n return alignments[0][0], alignments[0][1]\\n\\n if at_genome_start:\\n best_pos = last_gap_end_in_string(alignments[0][1])\\n else:\\n best_pos = alignments[0][1].find(\\\"-\\\")\\n\\n best = alignments[0]\\n\\n for a in alignments[1:]:\\n if at_genome_start:\\n gap_pos = last_gap_end_in_string(a[1])\\n else:\\n gap_pos = a[1].find(\\\"-\\\")\\n\\n if gap_pos > best_pos:\\n best = a\\n best_pos = gap_pos\\n\\n return best[0], best[1]\",\n \"def score_function(word1, word2):\\n if word2 == '':\\n return len(word1)\\n elif word1 == '':\\n return len(word2)\\n elif word1 == word2:\\n return 0\\n elif word1[0] == word2[0]:\\n return 0 + score_function(word1[1:], word2[1:])\\n else:\\n add_char = 1 + score_function(word2[0] + word1[:], word2[:])\\n sub_char = 1 + score_function(word1[1:], word2[1:])\\n remove_char = 1 + score_function(word1[1:], word2[:])\\n return min(add_char, sub_char, remove_char)\\n # if word1 == word2: # Fill in the condition\\n # # BEGIN Q6\\n # return 0\\n # # END Q6\\n # elif word1[0] == word2[0]: # Feel free to remove or add additional cases\\n # # BEGIN Q6\\n # return score_function(word1[1:], word2[1:])\\n # # END Q6\\n # else:\\n #\\n # elif len(word1) > len(word2):\\n # difference = len(word2) - len(word1)\\n # word2 = word2[0:len(word1)]\\n # return difference + score_function(word1, word2)\\n # elif len(word1) == len(word2):\\n # total = 0\\n # for i in word1:\\n # if word1[i] == word2[i]:\\n # total += 1\\n # return total\\n # elif len(word1) < len(word2):\\n # difference = len(word2) - len(word1)\\n # word1 = word1 + word2[len(word1):]\\n # return difference + score_function(word1, word2)\\n # else:\\n #\\n # def add_char(word1, word2):\\n # while len(word1) <= len(word2):\\n # return swap_score(word1, word2)\\n # return 0\\n #\\n # def remove_char(word1, word2):\\n # while len(word1) >= len(word2):\\n # if word1[0] != word2[0]:\\n # return 1 + remove_char(word1[1:], word2[1:])\\n # return 0\\n #\\n # def sub_char(word1, word2):\\n # if len(word1) == len(word2):\\n # if word1[0] == word2[0]:\\n # return 0\\n # else:\\n # return 1 + sub_char(word1[1:], word2[1:])\\n # return 0\\n # # BEGIN Q6\\n # return add_char(word1, word2) + remove_char(word1, word2) + sub_char(word1, word2)\\n # # END Q6\",\n \"def __init__(self) -> None:\\n\\n super(Levenshtein, self).__init__()\",\n \"def hamdist(str1, str2):\\n\\n diffs = 0\\n for ch1, ch2 in zip(str1, str2):\\n if ch1 != ch2:\\n diffs += 1\\n return diffs\",\n \"def add_substring_match_features(self,lst1,lst2,normalize_factor = 1.):\\n for j in range(self.WILD_LOW,self.WILD_HI+1):\\n self.features.append(Measures.longest_substring_with_wildcards(lst1, lst2, j) / normalize_factor)\",\n \"def most_similar_matching(self):\\n min_sim_thresh = float(self._conf.get(\\\"min_similarity_threshold\\\"))\\n most_similar_words = self.model_request.most_similar(positive=[self.base_word],\\n top_n=self._conf.get(\\\"max_similar_terms_threshold\\\"))\\n\\n # iterate through the most similar word list\\n match_found = False\\n for similar_word, sim in most_similar_words:\\n if sim > min_sim_thresh and not match_found:\\n\\n # 4.1 - find exact match in ontology.\\n result = self.graphdb.get_record_using_exact_matching(similar_word)\\n\\n if self.match_found(result):\\n threshold_reached, result, cor_walk = self.check_match_results(result)\\n if threshold_reached:\\n match_found = True\\n self.save_finding(self.ft_found_terms, similar_word, result,\\n cor_walk, self._conf.get(\\\"FT_DIRECT\\\"))\\n\\n else:\\n # 4.2 - Convert word into lemma and find exact match in ontology.\\n match_found = self.modify_and_test_word(self.ft_found_terms, similar_word, self._conf.get(\\\"MOD_FT\\\"))\\n\\n artificial_results = self.graphdb.get_records_with_artificial_relation(similar_word)\\n if len(artificial_results[\\\"results\\\"][\\\"bindings\\\"]) > 0:\\n self.save_finding(self.artificial_found_terms, similar_word, artificial_results,\\n None, self._conf.get(\\\"ARTIFICIAL_MATCH\\\"))\\n\\n self.sorted_ft_findings = self.sort_ft_similar_word_findings(self.ft_found_terms)\",\n \"def iterated_lev_dist(a, b, tolerance=5):\\n lenA, lenB = _len(a), _len(b)\\n\\n # Optimize away edge cases...\\n if a == b:\\n return 0\\n\\n # Lower bound is length diff, quit if length difference is too big\\n if _abs(lenA - lenB) > tolerance:\\n return -1\\n\\n # Quit early if we know the minimum number of substitutions to make will\\n # already be too big\\n min_substitutions = _len(_symdif({*a}, {*b})) / 2\\n if min_substitutions > tolerance:\\n return -1\\n\\n # We need 2 arrays, 1 larger than the compared\\n slots = _len(b) + 1\\n v0 = list(range(slots))\\n v1 = [0] * slots\\n\\n # print(' ', ' '.join(t))\\n # Walking over rows. Each row represents one step along the source string.\\n # Last cell of last row gives us the edit distance.\\n for i, A in enumerate(a):\\n # First cell of each row is for comparison against empty string\\n # the cost is always equal to length of source string walked so far\\n v1[0] = i + 1\\n\\n for j, B in enumerate(b):\\n delCost = v0[j + 1] + 1 # j+1 since the first value in the row\\n # is distance from an empty str\\n subCost = v0[j] + (A != B) # substitution\\n insCost = v1[j] + 1 # the insert cost is always at least 1\\n v1[j + 1] = _min(delCost, insCost, subCost)\\n\\n # When moving to next row, current row\\n v0 = _lcopy(v1)\\n # print(A, v0)\\n return v0[-1]\",\n \"def exact_distance_matcher_inefficient(database, query):\\n from scipy.spatial.distance import cdist\\n distances = cdist(query.reshape(1, -1), database.T)\\n list_refined = np.argsort(distances, axis=1).T\\n return list_refined\",\n \"def name_match_score(card_name: str, query: str) -> float:\\n # iterate over blocks of matching characters as returned by\\n # difflib, to get\\n # - \\\"match_size\\\", the number of matching characters\\n # - \\\"match_cost\\\", the number of edit operations from the card name\\n # to the search query\\n if query.islower():\\n card_name = card_name.lower()\\n s = difflib.SequenceMatcher(str.isspace, query, card_name, autojunk=False)\\n blocks = s.get_matching_blocks()\\n match_size = 0\\n match_cost = len(query)\\n pos = 0\\n for block in blocks:\\n # we matched `block.size` characters and we skipped over the\\n # substring `card_name[pos : block.b]`\\n match_size += block.size\\n num_unmatched_words = len(card_name[pos : block.b].split())\\n if block.b < len(card_name):\\n # cost 1 per word in the skipped substring\\n match_cost += num_unmatched_words\\n else:\\n # special case: we skipped over the whole rest of the\\n # string. cost 1 to skip the rest, plus 1 to skip to the\\n # end of the current word if we were in the middle of one.\\n if num_unmatched_words > 0:\\n match_cost += 1\\n if (\\n num_unmatched_words > 1\\n and pos < len(card_name)\\n and not card_name[pos].isspace()\\n and not card_name[pos] == \\\",\\\"\\n ):\\n match_cost += 1\\n # set `pos` to the end of the matching block\\n pos = block.b + block.size\\n # difflib always produces a dummy block at the end.\\n assert pos == len(card_name)\\n return match_size / match_cost\",\n \"def is_words_similar(string, model):\\n\\n if fuzz.ratio(string, model, score_cutoff=75):\\n return True\\n\\n return False\",\n \"def pos_match(self, a, b, threshold=0.5):\\r\\n # pos_a = map(self.get_wordnet_pos, nltk.pos_tag(word_tokenize(a)))\\r\\n # pos_b = map(self.get_wordnet_pos, nltk.pos_tag(word_tokenize(b)))\\r\\n pos_a = [self.get_wordnet_pos(token) for token in nltk.pos_tag(word_tokenize(a))]\\r\\n pos_b = [self.get_wordnet_pos(token) for token in nltk.pos_tag(word_tokenize(b))]\\r\\n lemmae_a = [self.lemmatizer.lemmatize(token.lower().strip(string.punctuation), pos) for token, pos in pos_a \\\\\\r\\n if pos == wordnet.NOUN and token.lower().strip(string.punctuation) not in self.stopwords]\\r\\n lemmae_b = [self.lemmatizer.lemmatize(token.lower().strip(string.punctuation), pos) for token, pos in pos_b \\\\\\r\\n if pos == wordnet.NOUN and token.lower().strip(string.punctuation) not in self.stopwords]\\r\\n\\r\\n # Calculate Jaccard similarity\\r\\n ratio = len(set(lemmae_a).intersection(lemmae_b)) / float(len(set(lemmae_a).union(lemmae_b)))\\r\\n return ratio\\r\\n # if ratio >= threshold: return ratio\\r\\n # return (ratio >= threshold)\\r\",\n \"def average_distance(l1, l2, distance_function=None):\\n\\n if not distance_function:\\n distance_function = levenshtein_ratio\\n counter = 0.0\\n numerator = 0.0\\n \\n #compute array of values\\n# if not l1 or not l2:\\n# return 1.0\\n #make l1 the shortes\\n l1, l2 = len(l1)<len(l2) and (l1, l2) or (l2, l1)\\n \\n #compute the distrances\\n distances = []\\n for s1 in l1:\\n distances += [(distance_function(s1, s2), s1, s2) for s2 in l2]\\n# ls.sort(reverse=True)\\n# distances.append((ls, s1))\\n distances.sort(reverse=True)\\n #compute maxima for each colum and each row\\n done = set()\\n for d, s1, s2 in distances:\\n if s1 not in done and s2 not in done:\\n done.add(s1)\\n done.add(s2) \\n counter += d\\n numerator += 1\\n #if there is a difference in length, we penalize for each item \\n difference = len(l2) - len(l1)\\n counter += .8 * difference\\n numerator += difference\\n if numerator == 0:\\n return 1.0\\n return counter/numerator\",\n \"def weighted_levenshtein(seq1, seq2, weights, r=0.9, normalise=False):\\n\\tx1 = 1 + len(seq1)\\n\\tx2 = 1 + len(seq2)\\n\\n\\talpha = r / ((1 - r) * average_distance)\\n\\n\\t# Initialisation of the matrix\\n\\td = [] # Using Numpy structures for this is probably not more efficient\\n\\ttmp = 0.0\\n\\tfirst_line = [tmp]\\n\\tfor e in seq2:\\n\\t\\ttmp += weights.get(e, 1)\\n\\t\\tfirst_line.append(tmp)\\n\\td.append(first_line)\\n\\ttmp = 0\\n\\tfor e in seq1:\\n\\t\\ttmp += weights.get(e, 1)\\n\\t\\td.append([tmp] * x2)\\n\\n\\t# Core of the algorithm\\n\\tfor i in range(1, x1):\\n\\t\\tfor j in range(1, x2):\\n\\t\\t\\te1 = seq1[i-1]\\n\\t\\t\\te2 = seq2[j-1]\\n\\n\\t\\t\\tw1 = weights.get(e1, 1)\\n\\t\\t\\tw2 = weights.get(e2, 1)\\n\\n\\t\\t\\td[i][j] = min(\\n\\t\\t\\t\\t(d[(i-1)][j] + w1), # Deletion of seq1[i]\\n\\t\\t\\t\\t(d[i][(j-1)] + w2), # Insertion of seq2[j]\\n\\t\\t\\t\\t(d[(i-1)][(j-1)] + (int(e1 != e2) * max(w1, w2))) # Substitution from seq1[i] to seq2[j]\\n\\t\\t\\t)\\n\\n\\traw = d[-1][-1]\\n\\n\\tif(normalise): return (raw / (d[0][-1] + d[-1][0]))\\n\\treturn raw\",\n \"def Lev(self,testDf,listCourse,inCourse):\\r\\n #Obtain the couse names for the two courses provided\\r\\n A = self.trainDF['name'][listCourse]\\r\\n B = testDf['name'][inCourse]\\r\\n #Figure out the length of the longest course name.\\r\\n maxLen = max(len(A),len(B))\\r\\n #Calculate the compliment of the normalized Levenshtein distance. \\r\\n return 1-LV.distance(A,B)/maxLen\",\n \"def test_single_word(self):\\n score = location.match_weight('clevedon', ['clevedon'])\\n\\n self.assertEqual(score, 1000)\",\n \"def fn(i1, i2):\\n if i1 == len(word1): return len(word2) - i2\\n if i2 == len(word2): return len(word1) - i1\\n if word1[i1] == word2[i2]: return fn(i1+1, i2+1)\\n return 1 + min(fn(i1+1,i2), fn(i1, i2+1))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65816826","0.64453566","0.6444688","0.64391017","0.63947976","0.63769424","0.63476413","0.6301144","0.6251837","0.61857057","0.6146241","0.6121829","0.6104246","0.6104119","0.607645","0.60713935","0.6024334","0.60240644","0.60073864","0.5990242","0.5945959","0.5916602","0.59081924","0.58841723","0.58659184","0.5864661","0.58642524","0.5852183","0.58376956","0.58364713","0.58364713","0.58341235","0.58319086","0.5825715","0.58248067","0.5796641","0.5795233","0.5793865","0.5786121","0.5775082","0.57668704","0.5754876","0.5734649","0.5716207","0.5707749","0.5694897","0.5649576","0.5643666","0.5617704","0.56047636","0.5601998","0.5574885","0.55390924","0.55239064","0.5521286","0.55209625","0.5520128","0.5511371","0.550719","0.5506241","0.5504366","0.5503271","0.55028534","0.54956096","0.5491021","0.54846996","0.54799247","0.54797953","0.54676056","0.54637885","0.54586107","0.5447191","0.5432083","0.5425976","0.5425653","0.54181683","0.5410166","0.53873837","0.5378432","0.5366877","0.53665876","0.5359658","0.53429043","0.5339199","0.533869","0.53361815","0.53335184","0.5333068","0.53309155","0.5330604","0.53271127","0.53209424","0.5313691","0.53053516","0.53047943","0.5301611","0.5297386","0.52905065","0.52899086","0.5285872"],"string":"[\n \"0.65816826\",\n \"0.64453566\",\n \"0.6444688\",\n \"0.64391017\",\n \"0.63947976\",\n \"0.63769424\",\n \"0.63476413\",\n \"0.6301144\",\n \"0.6251837\",\n \"0.61857057\",\n \"0.6146241\",\n \"0.6121829\",\n \"0.6104246\",\n \"0.6104119\",\n \"0.607645\",\n \"0.60713935\",\n \"0.6024334\",\n \"0.60240644\",\n \"0.60073864\",\n \"0.5990242\",\n \"0.5945959\",\n \"0.5916602\",\n \"0.59081924\",\n \"0.58841723\",\n \"0.58659184\",\n \"0.5864661\",\n \"0.58642524\",\n \"0.5852183\",\n \"0.58376956\",\n \"0.58364713\",\n \"0.58364713\",\n \"0.58341235\",\n \"0.58319086\",\n \"0.5825715\",\n \"0.58248067\",\n \"0.5796641\",\n \"0.5795233\",\n \"0.5793865\",\n \"0.5786121\",\n \"0.5775082\",\n \"0.57668704\",\n \"0.5754876\",\n \"0.5734649\",\n \"0.5716207\",\n \"0.5707749\",\n \"0.5694897\",\n \"0.5649576\",\n \"0.5643666\",\n \"0.5617704\",\n \"0.56047636\",\n \"0.5601998\",\n \"0.5574885\",\n \"0.55390924\",\n \"0.55239064\",\n \"0.5521286\",\n \"0.55209625\",\n \"0.5520128\",\n \"0.5511371\",\n \"0.550719\",\n \"0.5506241\",\n \"0.5504366\",\n \"0.5503271\",\n \"0.55028534\",\n \"0.54956096\",\n \"0.5491021\",\n \"0.54846996\",\n \"0.54799247\",\n \"0.54797953\",\n \"0.54676056\",\n \"0.54637885\",\n \"0.54586107\",\n \"0.5447191\",\n \"0.5432083\",\n \"0.5425976\",\n \"0.5425653\",\n \"0.54181683\",\n \"0.5410166\",\n \"0.53873837\",\n \"0.5378432\",\n \"0.5366877\",\n \"0.53665876\",\n \"0.5359658\",\n \"0.53429043\",\n \"0.5339199\",\n \"0.533869\",\n \"0.53361815\",\n \"0.53335184\",\n \"0.5333068\",\n \"0.53309155\",\n \"0.5330604\",\n \"0.53271127\",\n \"0.53209424\",\n \"0.5313691\",\n \"0.53053516\",\n \"0.53047943\",\n \"0.5301611\",\n \"0.5297386\",\n \"0.52905065\",\n \"0.52899086\",\n \"0.5285872\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.66017675"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":24571,"cells":{"query":{"kind":"string","value":"TypesConsoleCertificateSettings a model defined in OpenAPI"},"document":{"kind":"string","value":"def __init__(self, check_revocation=None, console_ca_cert=None, console_custom_cert=None, hpkp=None, local_vars_configuration=None): # noqa: E501 # noqa: E501\n if local_vars_configuration is None:\n local_vars_configuration = Configuration.get_default_copy()\n self.local_vars_configuration = local_vars_configuration\n\n self._check_revocation = None\n self._console_ca_cert = None\n self._console_custom_cert = None\n self._hpkp = None\n self.discriminator = None\n\n if check_revocation is not None:\n self.check_revocation = check_revocation\n if console_ca_cert is not None:\n self.console_ca_cert = console_ca_cert\n if console_custom_cert is not None:\n self.console_custom_cert = console_custom_cert\n if hpkp is not None:\n self.hpkp = hpkp"},"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 __init__(self):\n self.swagger_types = {\n 'id_conta': 'int',\n 'id_pessoa': 'int',\n 'id_cartao': 'int',\n 'id_bandeira': 'int',\n 'id_tipo_cartao': 'int',\n 'numero_cartao': 'str',\n 'nome_plastico': 'str',\n 'cvv2': 'str',\n 'data_geracao': 'str',\n 'data_validade': 'str',\n 'cpf': 'str',\n 'tipo_portador': 'str',\n 'trilha1': 'str',\n 'trilha2': 'str',\n 'trilha_cvv1': 'str',\n 'trilha_cvv2': 'str',\n 'flag_virtual': 'int',\n 'nome_bandeira': 'str',\n 'flag_titular': 'int',\n 'sequencial_cartao': 'int',\n 'id_status': 'int',\n 'descricao_status_cartao': 'str',\n 'data_status': 'str',\n 'id_estagio': 'int',\n 'descricao_estagio': 'str',\n 'data_estagio': 'str',\n 'numero_bin': 'str',\n 'id_produto': 'int',\n 'descricao_produto': 'str',\n 'id_status_conta': 'int',\n 'descricao_status_conta': 'int',\n 'data_embossing': 'str',\n 'codigo_desbloqueio': 'str',\n 'nome_pessoa': 'str',\n 'tipo_pessoa': 'str',\n 'data_nascimento': 'str',\n 'id_endereco': 'int',\n 'id_tipo_endereco': 'int',\n 'descricao_tipo_endereco': 'str',\n 'cep': 'str',\n 'logradouro': 'str',\n 'numero_endereco': 'str',\n 'complemento_endereco': 'str',\n 'bairro': 'str',\n 'cidade': 'str',\n 'uf': 'str',\n 'pais': 'str',\n 'senha_criptografada': 'str',\n 'icvv': 'str',\n 'id_status_impressao': 'int'\n }\n\n self.attribute_map = {\n 'id_conta': 'idConta',\n 'id_pessoa': 'idPessoa',\n 'id_cartao': 'idCartao',\n 'id_bandeira': 'idBandeira',\n 'id_tipo_cartao': 'idTipoCartao',\n 'numero_cartao': 'numeroCartao',\n 'nome_plastico': 'nomePlastico',\n 'cvv2': 'cvv2',\n 'data_geracao': 'dataGeracao',\n 'data_validade': 'dataValidade',\n 'cpf': 'cpf',\n 'tipo_portador': 'tipoPortador',\n 'trilha1': 'trilha1',\n 'trilha2': 'trilha2',\n 'trilha_cvv1': 'trilhaCVV1',\n 'trilha_cvv2': 'trilhaCVV2',\n 'flag_virtual': 'flagVirtual',\n 'nome_bandeira': 'nomeBandeira',\n 'flag_titular': 'flagTitular',\n 'sequencial_cartao': 'sequencialCartao',\n 'id_status': 'idStatus',\n 'descricao_status_cartao': 'descricaoStatusCartao',\n 'data_status': 'dataStatus',\n 'id_estagio': 'idEstagio',\n 'descricao_estagio': 'descricaoEstagio',\n 'data_estagio': 'dataEstagio',\n 'numero_bin': 'numeroBin',\n 'id_produto': 'idProduto',\n 'descricao_produto': 'descricaoProduto',\n 'id_status_conta': 'idStatusConta',\n 'descricao_status_conta': 'descricaoStatusConta',\n 'data_embossing': 'dataEmbossing',\n 'codigo_desbloqueio': 'codigoDesbloqueio',\n 'nome_pessoa': 'nomePessoa',\n 'tipo_pessoa': 'tipoPessoa',\n 'data_nascimento': 'dataNascimento',\n 'id_endereco': 'idEndereco',\n 'id_tipo_endereco': 'idTipoEndereco',\n 'descricao_tipo_endereco': 'descricaoTipoEndereco',\n 'cep': 'cep',\n 'logradouro': 'logradouro',\n 'numero_endereco': 'numeroEndereco',\n 'complemento_endereco': 'complementoEndereco',\n 'bairro': 'bairro',\n 'cidade': 'cidade',\n 'uf': 'uf',\n 'pais': 'pais',\n 'senha_criptografada': 'senhaCriptografada',\n 'icvv': 'icvv',\n 'id_status_impressao': 'idStatusImpressao'\n }\n\n self._id_conta = None\n self._id_pessoa = None\n self._id_cartao = None\n self._id_bandeira = None\n self._id_tipo_cartao = None\n self._numero_cartao = None\n self._nome_plastico = None\n self._cvv2 = None\n self._data_geracao = None\n self._data_validade = None\n self._cpf = None\n self._tipo_portador = None\n self._trilha1 = None\n self._trilha2 = None\n self._trilha_cvv1 = None\n self._trilha_cvv2 = None\n self._flag_virtual = None\n self._nome_bandeira = None\n self._flag_titular = None\n self._sequencial_cartao = None\n self._id_status = None\n self._descricao_status_cartao = None\n self._data_status = None\n self._id_estagio = None\n self._descricao_estagio = None\n self._data_estagio = None\n self._numero_bin = None\n self._id_produto = None\n self._descricao_produto = None\n self._id_status_conta = None\n self._descricao_status_conta = None\n self._data_embossing = None\n self._codigo_desbloqueio = None\n self._nome_pessoa = None\n self._tipo_pessoa = None\n self._data_nascimento = None\n self._id_endereco = None\n self._id_tipo_endereco = None\n self._descricao_tipo_endereco = None\n self._cep = None\n self._logradouro = None\n self._numero_endereco = None\n self._complemento_endereco = None\n self._bairro = None\n self._cidade = None\n self._uf = None\n self._pais = None\n self._senha_criptografada = None\n self._icvv = None\n self._id_status_impressao = None","def __init__(__self__, *,\n type: pulumi.Input[str],\n content: Optional[pulumi.Input[str]] = None):\n pulumi.set(__self__, \"type\", 'ContentCertificate')\n if content is not None:\n pulumi.set(__self__, \"content\", content)","def __init__(__self__, *,\n auth_type: pulumi.Input[str],\n certificate: pulumi.Input[str],\n client_id: pulumi.Input[str],\n principal_id: pulumi.Input[str]):\n pulumi.set(__self__, \"auth_type\", 'servicePrincipalCertificate')\n pulumi.set(__self__, \"certificate\", certificate)\n pulumi.set(__self__, \"client_id\", client_id)\n pulumi.set(__self__, \"principal_id\", principal_id)","def Certificate(self) -> _n_8_t_0:","def Certificate(self) -> _n_8_t_0:","def __init__(__self__, *,\n key_vault_cert_name: pulumi.Input[str],\n type: pulumi.Input[str],\n vault_uri: pulumi.Input[str],\n cert_version: Optional[pulumi.Input[str]] = None,\n exclude_private_key: Optional[pulumi.Input[bool]] = None):\n pulumi.set(__self__, \"key_vault_cert_name\", key_vault_cert_name)\n pulumi.set(__self__, \"type\", 'KeyVaultCertificate')\n pulumi.set(__self__, \"vault_uri\", vault_uri)\n if cert_version is not None:\n pulumi.set(__self__, \"cert_version\", cert_version)\n if exclude_private_key is None:\n exclude_private_key = False\n if exclude_private_key is not None:\n pulumi.set(__self__, \"exclude_private_key\", exclude_private_key)","def test_valid_settings() -> None:\n SwaggerTesterSettings()","def __init__(self):\n self.swagger_types = {\n 'id': 'str',\n 'name': 'str',\n 'uses_git': 'bool',\n 'git_remote_url': 'str',\n 'git_username': 'str',\n 'git_password': 'str',\n 'git_username_user_attribute': 'str',\n 'git_password_user_attribute': 'str',\n 'git_service_name': 'str',\n 'deploy_secret': 'str',\n 'unset_deploy_secret': 'bool',\n 'pull_request_mode': 'str',\n 'validation_required': 'bool',\n 'allow_warnings': 'bool',\n 'is_example': 'bool',\n 'can': 'dict(str, bool)'\n }\n\n self.attribute_map = {\n 'id': 'id',\n 'name': 'name',\n 'uses_git': 'uses_git',\n 'git_remote_url': 'git_remote_url',\n 'git_username': 'git_username',\n 'git_password': 'git_password',\n 'git_username_user_attribute': 'git_username_user_attribute',\n 'git_password_user_attribute': 'git_password_user_attribute',\n 'git_service_name': 'git_service_name',\n 'deploy_secret': 'deploy_secret',\n 'unset_deploy_secret': 'unset_deploy_secret',\n 'pull_request_mode': 'pull_request_mode',\n 'validation_required': 'validation_required',\n 'allow_warnings': 'allow_warnings',\n 'is_example': 'is_example',\n 'can': 'can'\n }\n\n self._id = None\n self._name = None\n self._uses_git = None\n self._git_remote_url = None\n self._git_username = None\n self._git_password = None\n self._git_username_user_attribute = None\n self._git_password_user_attribute = None\n self._git_service_name = None\n self._deploy_secret = None\n self._unset_deploy_secret = None\n self._pull_request_mode = None\n self._validation_required = None\n self._allow_warnings = None\n self._is_example = None\n self._can = None","def __init__(self, ca, cert_type):\n self.ca = ca # required\n self.nonce = None # optional, has default = os.urandom(32)\n self.public_key_comment = None\n self.serial = None # can be set, has default = 0\n self.cert_type = None # required: User = 1, Host = 2\n self.key_id = None # optional, default = ''\n self.valid_principals = list() # optional, default = ''\n self.valid_after = None # optional, default = 0\n self.valid_before = None # optional, default = 2^64-1\n self.critical_option_force_command = None # optional, default = ''\n self.critical_option_source_address = None # optional, default = ''\n self.extensions = None # optional, default = ''\n self.reserved = '' # should always be this value\n self.signature = None\n self.signed_cert = None\n self.public_key_comment = None\n self.cert_type = cert_type","def get_ssl_ca_settings():\n ca_data = {}\n https_service_endpoints = config('https-service-endpoints')\n if (https_service_endpoints and\n bool_from_string(https_service_endpoints)):\n # Pass CA cert as client will need it to\n # verify https connections\n ca = get_ca(user=SSH_USER)\n ca_bundle = ca.get_ca_bundle()\n ca_data['https_keystone'] = 'True'\n ca_data['ca_cert'] = b64encode(ca_bundle)\n return ca_data","def __init__(self):\n self.swagger_types = {\n 'enabled': 'bool',\n 'auto_review': 'bool',\n 'allow_direct_trades': 'bool',\n 'min_hours_in_future': 'int',\n 'unequal_paid': 'str',\n 'one_sided': 'str',\n 'weekly_min_paid_violations': 'str',\n 'weekly_max_paid_violations': 'str',\n 'requires_matching_queues': 'bool',\n 'requires_matching_languages': 'bool',\n 'requires_matching_skills': 'bool',\n 'requires_matching_planning_groups': 'bool',\n 'activity_category_rules': 'list[ShiftTradeActivityRule]'\n }\n\n self.attribute_map = {\n 'enabled': 'enabled',\n 'auto_review': 'autoReview',\n 'allow_direct_trades': 'allowDirectTrades',\n 'min_hours_in_future': 'minHoursInFuture',\n 'unequal_paid': 'unequalPaid',\n 'one_sided': 'oneSided',\n 'weekly_min_paid_violations': 'weeklyMinPaidViolations',\n 'weekly_max_paid_violations': 'weeklyMaxPaidViolations',\n 'requires_matching_queues': 'requiresMatchingQueues',\n 'requires_matching_languages': 'requiresMatchingLanguages',\n 'requires_matching_skills': 'requiresMatchingSkills',\n 'requires_matching_planning_groups': 'requiresMatchingPlanningGroups',\n 'activity_category_rules': 'activityCategoryRules'\n }\n\n self._enabled = None\n self._auto_review = None\n self._allow_direct_trades = None\n self._min_hours_in_future = None\n self._unequal_paid = None\n self._one_sided = None\n self._weekly_min_paid_violations = None\n self._weekly_max_paid_violations = None\n self._requires_matching_queues = None\n self._requires_matching_languages = None\n self._requires_matching_skills = None\n self._requires_matching_planning_groups = None\n self._activity_category_rules = None","def __init__(self, **kwargs):\n self.swagger_types = {\n 'id': 'str',\n 'name': 'str',\n 'version': 'str',\n 'tagline': 'str',\n 'keywords': 'str',\n 'short_description': 'str',\n 'usage_information': 'str',\n 'long_description': 'str',\n 'license_model_description': 'str',\n 'system_requirements': 'str',\n 'time_released': 'datetime',\n 'release_notes': 'str',\n 'categories': 'list[str]',\n 'publisher': 'Publisher',\n 'languages': 'list[Item]',\n 'screenshots': 'list[Screenshot]',\n 'videos': 'list[NamedLink]',\n 'support_contacts': 'list[SupportContact]',\n 'support_links': 'list[NamedLink]',\n 'documentation_links': 'list[DocumentationLink]',\n 'icon': 'UploadData',\n 'banner': 'UploadData',\n 'regions': 'list[Region]',\n 'package_type': 'str',\n 'default_package_version': 'str',\n 'links': 'list[Link]',\n 'is_featured': 'bool'\n }\n\n self.attribute_map = {\n 'id': 'id',\n 'name': 'name',\n 'version': 'version',\n 'tagline': 'tagline',\n 'keywords': 'keywords',\n 'short_description': 'shortDescription',\n 'usage_information': 'usageInformation',\n 'long_description': 'longDescription',\n 'license_model_description': 'licenseModelDescription',\n 'system_requirements': 'systemRequirements',\n 'time_released': 'timeReleased',\n 'release_notes': 'releaseNotes',\n 'categories': 'categories',\n 'publisher': 'publisher',\n 'languages': 'languages',\n 'screenshots': 'screenshots',\n 'videos': 'videos',\n 'support_contacts': 'supportContacts',\n 'support_links': 'supportLinks',\n 'documentation_links': 'documentationLinks',\n 'icon': 'icon',\n 'banner': 'banner',\n 'regions': 'regions',\n 'package_type': 'packageType',\n 'default_package_version': 'defaultPackageVersion',\n 'links': 'links',\n 'is_featured': 'isFeatured'\n }\n\n self._id = None\n self._name = None\n self._version = None\n self._tagline = None\n self._keywords = None\n self._short_description = None\n self._usage_information = None\n self._long_description = None\n self._license_model_description = None\n self._system_requirements = None\n self._time_released = None\n self._release_notes = None\n self._categories = None\n self._publisher = None\n self._languages = None\n self._screenshots = None\n self._videos = None\n self._support_contacts = None\n self._support_links = None\n self._documentation_links = None\n self._icon = None\n self._banner = None\n self._regions = None\n self._package_type = None\n self._default_package_version = None\n self._links = None\n self._is_featured = None","def __init__(self):\n self.swagger_types = {\n 'access_zone': 'str',\n 'aggregation_mode': 'str',\n 'alloc_method': 'str',\n 'description': 'str',\n 'ifaces': 'list[SubnetsSubnetPoolIface]',\n 'name': 'str',\n 'ranges': 'list[SubnetsSubnetPoolRange]',\n 'rebalance_policy': 'str',\n 'sc_auto_unsuspend_delay': 'int',\n 'sc_connect_policy': 'str',\n 'sc_dns_zone': 'str',\n 'sc_dns_zone_aliases': 'list[str]',\n 'sc_failover_policy': 'str',\n 'sc_subnet': 'str',\n 'sc_ttl': 'int',\n 'static_routes': 'list[SubnetsSubnetPoolStaticRoute]'\n }\n\n self.attribute_map = {\n 'access_zone': 'access_zone',\n 'aggregation_mode': 'aggregation_mode',\n 'alloc_method': 'alloc_method',\n 'description': 'description',\n 'ifaces': 'ifaces',\n 'name': 'name',\n 'ranges': 'ranges',\n 'rebalance_policy': 'rebalance_policy',\n 'sc_auto_unsuspend_delay': 'sc_auto_unsuspend_delay',\n 'sc_connect_policy': 'sc_connect_policy',\n 'sc_dns_zone': 'sc_dns_zone',\n 'sc_dns_zone_aliases': 'sc_dns_zone_aliases',\n 'sc_failover_policy': 'sc_failover_policy',\n 'sc_subnet': 'sc_subnet',\n 'sc_ttl': 'sc_ttl',\n 'static_routes': 'static_routes'\n }\n\n self._access_zone = None\n self._aggregation_mode = None\n self._alloc_method = None\n self._description = None\n self._ifaces = None\n self._name = None\n self._ranges = None\n self._rebalance_policy = None\n self._sc_auto_unsuspend_delay = None\n self._sc_connect_policy = None\n self._sc_dns_zone = None\n self._sc_dns_zone_aliases = None\n self._sc_failover_policy = None\n self._sc_subnet = None\n self._sc_ttl = None\n self._static_routes = None","def create_settings():\n\n settings = {}\n\n settings['induction'] = {'type': 'DT'}\n\n settings['selection'] = {'type': 'Base',\n 'its': 1,\n 'param': 1}\n\n settings['prediction'] = {'type': 'MI',\n 'its': 0.1,\n 'param': 0.95}\n\n settings['queries'] = {}\n\n settings['metadata'] = {}\n\n settings['model_data'] = {}\n\n return settings","def __init__(self):\n self.swagger_types = {\n 'id_conta': 'int',\n 'id_produto': 'int',\n 'id_pessoa': 'int',\n 'id_parentesco': 'int',\n 'tipo_portador': 'str',\n 'nome_impresso': 'str',\n 'id_tipo_cartao': 'int',\n 'flag_ativo': 'int',\n 'data_cadastro_portador': 'str',\n 'data_cancelamento_portador': 'str'\n }\n\n self.attribute_map = {\n 'id_conta': 'idConta',\n 'id_produto': 'idProduto',\n 'id_pessoa': 'idPessoa',\n 'id_parentesco': 'idParentesco',\n 'tipo_portador': 'tipoPortador',\n 'nome_impresso': 'nomeImpresso',\n 'id_tipo_cartao': 'idTipoCartao',\n 'flag_ativo': 'flagAtivo',\n 'data_cadastro_portador': 'dataCadastroPortador',\n 'data_cancelamento_portador': 'dataCancelamentoPortador'\n }\n\n self._id_conta = None\n self._id_produto = None\n self._id_pessoa = None\n self._id_parentesco = None\n self._tipo_portador = None\n self._nome_impresso = None\n self._id_tipo_cartao = None\n self._flag_ativo = None\n self._data_cadastro_portador = None\n self._data_cancelamento_portador = None","def config_schema():\n # pylint: disable=no-value-for-parameter\n return Schema(\n {\n Optional('other_settings', default={}): {\n Optional('master_only', default=False): Boolean(),\n Optional('skip_version_test', default=False): Boolean(),\n Optional('username', default=None): Any(None, *string_types),\n Optional('password', default=None): Any(None, *string_types),\n Optional('api_key', default={}): {\n Optional('id'): Any(None, *string_types),\n Optional('api_key'): Any(None, *string_types),\n Optional('token'): Any(None, *string_types),\n }\n },\n Optional('client', default={}): {\n Optional('hosts', default=None): Any(None, list, *string_types),\n Optional('cloud_id', default=None): Any(None, *string_types),\n Optional('api_key'): Any(None, tuple),\n Optional('basic_auth'): Any(None, tuple),\n Optional('bearer_auth'): Any(None, *string_types),\n Optional('opaque_id'): Any(None, *string_types),\n Optional('headers'): Any(None, dict),\n Optional('connections_per_node'): Any(None, All(Coerce(int), Range(min=1, max=100))),\n Optional('http_compress'): Boolean(),\n Optional('verify_certs'): Boolean(),\n Optional('ca_certs'): Any(None, *string_types),\n Optional('client_cert'): Any(None, *string_types),\n Optional('client_key'): Any(None, *string_types),\n\n #: Hostname or IP address to verify on the node's certificate.\n #: This is useful if the certificate contains a different value\n #: than the one supplied in ``host``. An example of this situation\n #: is connecting to an IP address instead of a hostname.\n #: Set to ``False`` to disable certificate hostname verification.\n Optional('ssl_assert_hostname'): Any(None, *string_types),\n\n #: SHA-256 fingerprint of the node's certificate. If this value is\n #: given then root-of-trust verification isn't done and only the\n #: node's certificate fingerprint is verified.\n #:\n #: On CPython 3.10+ this also verifies if any certificate in the\n #: chain including the Root CA matches this fingerprint. However\n #: because this requires using private APIs support for this is\n #: **experimental**.\n Optional('ssl_assert_fingerprint'): Any(None, *string_types),\n\n Optional('ssl_version'): Any(None, *string_types), # Minimum acceptable TLS/SSL version\n\n #: Pre-configured :class:`ssl.SSLContext` OBJECT. If this value\n #: is given then no other TLS options (besides ``ssl_assert_fingerprint``)\n #: can be set on the :class:`elastic_transport.NodeConfig`.\n ### Keeping this here in case someone APIs it, but otherwise it's not likely to be used.\n Optional('ssl_context'): Any(None, *string_types),\n\n Optional('ssl_show_warn'): Boolean(),\n Optional('transport_class'): Any(None, *string_types),\n Optional('request_timeout'): Any(None, All(Coerce(float), Range(min=0.1, max=86400.0))),\n\n # node_class: Union[str, Type[BaseNode]] = Urllib3HttpNode,\n Optional('node_class'): Any(None, *string_types),\n\n # node_pool_class: Type[NodePool] = NodePool,\n Optional('node_pool_class'): Any(None, *string_types),\n\n Optional('randomize_nodes_in_pool'): Boolean(),\n\n # node_selector_class: Optional[Union[str, Type[NodeSelector]]] = None,\n Optional('node_selector_class'): Any(None, *string_types),\n\n Optional('dead_node_backoff_factor'): Any(None, float),\n Optional('max_dead_node_backoff'): Any(None, float),\n\n # One of:\n # \"Serializer\"\n # \"JsonSerializer\"\n # \"TextSerializer\"\n # \"NdjsonSerializer\"\n # \"CompatibilityModeJsonSerializer\"\n # \"CompatibilityModeNdjsonSerializer\"\n # \"MapboxVectorTileSerializer\"\n Optional('serializer'): Any(None, *string_types), # ???\n\n # :arg serializers: optional dict of serializer instances that will be\n # used for deserializing data coming from the server. (key is the mimetype)\n # e.g.: {'mimetype':'serializer'}\n # \"Serializer\"\n # \"JsonSerializer\"\n # \"TextSerializer\"\n # \"NdjsonSerializer\"\n # \"CompatibilityModeJsonSerializer\"\n # \"CompatibilityModeNdjsonSerializer\"\n # \"MapboxVectorTileSerializer\"\n Optional('serializers'): Any(None, dict),\n\n Optional('default_mimetype'): Any(None, *string_types),\n Optional('max_retries'): Any(None, All(Coerce(int), Range(min=1, max=100))),\n\n # retry_on_status: Collection[int] = (429, 502, 503, 504),\n Optional('retry_on_status'): Any(None, tuple),\n\n Optional('retry_on_timeout'): Boolean(),\n Optional('sniff_on_start'): Boolean(),\n Optional('sniff_before_requests'): Boolean(),\n Optional('sniff_on_node_failure'): Boolean(),\n Optional('sniff_timeout'): Any(None, All(Coerce(float), Range(min=0.1, max=100.0))),\n Optional('min_delay_between_sniffing'): Any(None, All(Coerce(float), Range(min=1, max=100.0))),\n\n # Optional[\n # Callable[\n # [\"Transport\", \"SniffOptions\"],\n # Union[List[NodeConfig], List[NodeConfig]],\n # ]\n # ] = None,\n Optional('sniffed_node_callback'): Any(None, *string_types),\n\n Optional('meta_header'): Boolean(),\n\n # Cannot specify both 'request_timeout' and 'timeout'\n # Optional('timeout', default=10.0): All(Coerce(float), Range(min=1, max=120)),\n\n # Cannot specify both 'randomize_hosts' and 'randomize_nodes_in_pool'\n # Optional('randomize_hosts', default=True): Boolean(),\n\n Optional('host_info_callback'): Any(None, *string_types), # ??? needs the name of a callback function\n\n # Cannot specify both 'sniffer_timeout' and 'min_delay_between_sniffing'\n # Optional('sniffer_timeout', default=0.5): All(Coerce(float), Range(min=0.1, max=10.0)),\n\n # Cannot specify both 'sniff_on_connection_fail' and 'sniff_on_node_failure'\n # Optional('sniff_on_connection_fail', default=False): Boolean(),\n\n # Optional('http_auth'): Any(None, *string_types), # ??? Favor basic_auth instead.w\n Optional('_transport'): Any(None, *string_types) # ???\n }\n }\n )","def __init__(self):\n self.swagger_types = {\n 'owner_id': 'str',\n 'created_at': 'datetime',\n 'identifier': 'str',\n 'identifier_type': 'str',\n 'default_language': 'str',\n 'optional_identifier': 'str',\n 'id': 'str',\n 'v': 'float',\n 'id': 'str',\n 'case_records': 'list[str]'\n }\n\n self.attribute_map = {\n 'owner_id': '_ownerId',\n 'created_at': '_createdAt',\n 'identifier': 'identifier',\n 'identifier_type': 'identifierType',\n 'default_language': 'defaultLanguage',\n 'optional_identifier': 'optionalIdentifier',\n 'id': '_id',\n 'v': '__v',\n 'case_records': 'caseRecords'\n }\n\n self._owner_id = None\n self._created_at = None\n self._identifier = None\n self._identifier_type = None\n self._default_language = None\n self._optional_identifier = None\n self._id = None\n self._v = None\n self._id = None\n self._case_records = None","def __init__(self): # noqa: E501\n self.openapi_types = {\n }\n\n self.attribute_map = {\n }","async def get_trace_settings(\n self,\n model_name: str = ...,\n headers: dict[str, t.Any] = ...,\n as_json: t.Literal[False] = ...,\n ) -> service_pb2.TraceSettingResponse:","def __init__(self):\n self.swagger_types = {\n 'id': 'str',\n 'domain': 'str',\n 'custom_domain': 'str',\n 'customer_email': 'str',\n 'customer_name': 'str',\n 'company': 'str',\n 'date_created': 'datetime',\n 'date_validity': 'datetime',\n 'status': 'str',\n 'account_id': 'str',\n 'cluster_id': 'str',\n 'task_id': 'str',\n 'version': 'str',\n 'is_latest': 'bool',\n 'product_id': 'str',\n 'variation_id': 'str'\n }\n\n self.attribute_map = {\n 'id': 'id',\n 'domain': 'domain',\n 'custom_domain': 'custom_domain',\n 'customer_email': 'customer_email',\n 'customer_name': 'customer_name',\n 'company': 'company',\n 'date_created': 'date_created',\n 'date_validity': 'date_validity',\n 'status': 'status',\n 'account_id': 'account_id',\n 'cluster_id': 'cluster_id',\n 'task_id': 'task_id',\n 'version': 'version',\n 'is_latest': 'is_latest',\n 'product_id': 'product_id',\n 'variation_id': 'variation_id'\n }\n\n self._id = None\n self._domain = None\n self._custom_domain = None\n self._customer_email = None\n self._customer_name = None\n self._company = None\n self._date_created = None\n self._date_validity = None\n self._status = None\n self._account_id = None\n self._cluster_id = None\n self._task_id = None\n self._version = None\n self._is_latest = None\n self._product_id = None\n self._variation_id = None","def __init__(self):\n self.swagger_types = {\n 'id': 'str',\n 'name': 'str',\n 'date_created': 'datetime',\n 'date_modified': 'datetime',\n 'version': 'int',\n 'division': 'DomainEntityRef',\n 'campaign_status': 'str',\n 'callable_time_set': 'DomainEntityRef',\n 'contact_list': 'DomainEntityRef',\n 'dnc_lists': 'list[DomainEntityRef]',\n 'always_running': 'bool',\n 'contact_sorts': 'list[ContactSort]',\n 'messages_per_minute': 'int',\n 'errors': 'list[RestErrorDetail]',\n 'sms_config': 'SmsConfig',\n 'self_uri': 'str'\n }\n\n self.attribute_map = {\n 'id': 'id',\n 'name': 'name',\n 'date_created': 'dateCreated',\n 'date_modified': 'dateModified',\n 'version': 'version',\n 'division': 'division',\n 'campaign_status': 'campaignStatus',\n 'callable_time_set': 'callableTimeSet',\n 'contact_list': 'contactList',\n 'dnc_lists': 'dncLists',\n 'always_running': 'alwaysRunning',\n 'contact_sorts': 'contactSorts',\n 'messages_per_minute': 'messagesPerMinute',\n 'errors': 'errors',\n 'sms_config': 'smsConfig',\n 'self_uri': 'selfUri'\n }\n\n self._id = None\n self._name = None\n self._date_created = None\n self._date_modified = None\n self._version = None\n self._division = None\n self._campaign_status = None\n self._callable_time_set = None\n self._contact_list = None\n self._dnc_lists = None\n self._always_running = None\n self._contact_sorts = None\n self._messages_per_minute = None\n self._errors = None\n self._sms_config = None\n self._self_uri = None","def settings_set_callsign(self):\n\n # The command parameters\n command_parameters = [\n {\n \"type\": \"string\",\n \"minlength\": 1,\n \"maxlength\": 1,\n \"required\": True,\n \"title\": \"callsign\",\n \"description\": \"The APRS callsign to be tracked.\"\n }\n ]\n\n return build_metadata_dict(command_parameters, 'set_callsign', self.name, requires_active_session = True,\n use_as_initial_value = True)","def settings(self) -> SchemaActionModel:\n from whyqd.models import SchemaActionModel\n\n action_settings = {\n \"name\": self.name,\n \"title\": self.title,\n \"description\": self.description,\n \"structure\": self.structure,\n }\n if self.modifiers:\n action_settings[\"modifiers\"] = self.modifiers\n return SchemaActionModel(**action_settings)","def settings(self):\r\n return SettingResource(self)","def cont_settings_(request):\n \n return {\"settings\": settings}","def save(self):\n self.client._perform_empty(\n \"PUT\", \"/projects/%s/apiservices/%s/settings\" % (self.project_key, self.service_id),\n body = self.settings)","def get_zcs_settings(session, return_type=None, **kwargs):\n path = '/api/settings/container_service.json'\n\n return session.get_api(path=path, return_type=return_type, **kwargs)","def get_conversion_options_schema(self) -> dict:\n conversion_options_schema = get_base_schema(\n root=True,\n id_=\"conversion_options.schema.json\",\n title=\"Conversion options schema\",\n description=\"Schema for the conversion options\",\n version=\"0.1.0\",\n )\n for interface_name, data_interface in self.data_interface_objects.items():\n conversion_options_schema[\"properties\"].update(\n {interface_name: unroot_schema(data_interface.get_conversion_options_schema())}\n )\n return conversion_options_schema","def get_conversion_options_schema(self) -> dict:\n conversion_options_schema = get_base_schema(\n root=True,\n id_=\"conversion_options.schema.json\",\n title=\"Conversion options schema\",\n description=\"Schema for the conversion options\",\n version=\"0.1.0\",\n )\n for interface_name, data_interface in self.data_interface_objects.items():\n conversion_options_schema[\"properties\"].update(\n {interface_name: unroot_schema(data_interface.get_conversion_options_schema())}\n )\n return conversion_options_schema","def settings_config(session, return_type=None, **kwargs):\n path = '/api/return_type.json'\n return session.get_api(path=path, return_type=return_type, **kwargs)","def settings(self):\n if self._settings is not None:\n return self._settings\n\n settings = self.binaries['KeeAgent.settings'].content\n self._settings = objectify.fromstring(settings)\n return self._settings","async def settings(self, ctx: BBContext):\n pass","def __init__(self):\n self.swagger_types = {\n 'autocreate': 'bool',\n 'autodelete': 'bool',\n 'global_visible_accessible': 'bool',\n 'local_root_accessible': 'bool',\n 'local_root_visible': 'bool',\n 'local_subdir_accessible': 'bool',\n 'nfs_root_accessible': 'bool',\n 'nfs_root_visible': 'bool',\n 'nfs_subdir_accessible': 'bool',\n 'reserve': 'float',\n 'service': 'bool',\n 'smb_root_accessible': 'bool',\n 'smb_root_visible': 'bool',\n 'smb_subdir_accessible': 'bool'\n }\n\n self.attribute_map = {\n 'autocreate': 'autocreate',\n 'autodelete': 'autodelete',\n 'global_visible_accessible': 'global_visible_accessible',\n 'local_root_accessible': 'local_root_accessible',\n 'local_root_visible': 'local_root_visible',\n 'local_subdir_accessible': 'local_subdir_accessible',\n 'nfs_root_accessible': 'nfs_root_accessible',\n 'nfs_root_visible': 'nfs_root_visible',\n 'nfs_subdir_accessible': 'nfs_subdir_accessible',\n 'reserve': 'reserve',\n 'service': 'service',\n 'smb_root_accessible': 'smb_root_accessible',\n 'smb_root_visible': 'smb_root_visible',\n 'smb_subdir_accessible': 'smb_subdir_accessible'\n }\n\n self._autocreate = None\n self._autodelete = None\n self._global_visible_accessible = None\n self._local_root_accessible = None\n self._local_root_visible = None\n self._local_subdir_accessible = None\n self._nfs_root_accessible = None\n self._nfs_root_visible = None\n self._nfs_subdir_accessible = None\n self._reserve = None\n self._service = None\n self._smb_root_accessible = None\n self._smb_root_visible = None\n self._smb_subdir_accessible = None","def test_create_hyperflex_proxy_setting_policy(self):\n pass","def to_dict(self):\n result = {}\n\n for attr, _ in six.iteritems(self.swagger_types):\n value = getattr(self, attr)\n if isinstance(value, list):\n result[attr] = list(map(\n lambda x: x.to_dict() if hasattr(x, \"to_dict\") else x,\n value\n ))\n elif hasattr(value, \"to_dict\"):\n result[attr] = value.to_dict()\n elif isinstance(value, dict):\n result[attr] = dict(map(\n lambda item: (item[0], item[1].to_dict())\n if hasattr(item[1], \"to_dict\") else item,\n value.items()\n ))\n else:\n result[attr] = value\n if issubclass(CertificatePayload, dict):\n for key, value in self.items():\n result[key] = value\n\n return result","def __init__(self):\n self.swagger_types = {\n 'app_id': 'int',\n 'app_sw_rev': 'str',\n 'avg_hops': 'float',\n 'avg_latency': 'int',\n 'charge': 'int',\n 'estimated_latency_to_mote': 'int',\n 'hw_model': 'int',\n 'hw_rev': 'int',\n 'id': 'int',\n 'join_sys_time': 'datetime',\n 'last_voltage': 'int',\n 'lost_packet_count': 'int',\n 'mac_address': 'str',\n 'max_current': 'int',\n 'max_num_links': 'int',\n 'max_num_neighbors': 'int',\n 'need_neighbor': 'bool',\n 'num_good_neighbors': 'int',\n 'num_joins': 'int',\n 'num_links': 'int',\n 'num_neighbors': 'int',\n 'num_parents': 'int',\n 'power_cost_rx_link': 'int',\n 'power_cost_tx_link': 'int',\n 'reliability': 'float',\n 'rx_packet_count': 'int',\n 'stack_sw_rev': 'str',\n 'state': 'str',\n 'state_reason': 'str',\n 'state_sys_time': 'datetime',\n 'used_current': 'int'\n }\n\n self.attribute_map = {\n 'app_id': 'appId',\n 'app_sw_rev': 'appSwRev',\n 'avg_hops': 'avgHops',\n 'avg_latency': 'avgLatency',\n 'charge': 'charge',\n 'estimated_latency_to_mote': 'estimatedLatencyToMote',\n 'hw_model': 'hwModel',\n 'hw_rev': 'hwRev',\n 'id': 'id',\n 'join_sys_time': 'joinSysTime',\n 'last_voltage': 'lastVoltage',\n 'lost_packet_count': 'lostPacketCount',\n 'mac_address': 'macAddress',\n 'max_current': 'maxCurrent',\n 'max_num_links': 'maxNumLinks',\n 'max_num_neighbors': 'maxNumNeighbors',\n 'need_neighbor': 'needNeighbor',\n 'num_good_neighbors': 'numGoodNeighbors',\n 'num_joins': 'numJoins',\n 'num_links': 'numLinks',\n 'num_neighbors': 'numNeighbors',\n 'num_parents': 'numParents',\n 'power_cost_rx_link': 'powerCostRxLink',\n 'power_cost_tx_link': 'powerCostTxLink',\n 'reliability': 'reliability',\n 'rx_packet_count': 'rxPacketCount',\n 'stack_sw_rev': 'stackSwRev',\n 'state': 'state',\n 'state_reason': 'stateReason',\n 'state_sys_time': 'stateSysTime',\n 'used_current': 'usedCurrent'\n }\n\n self._app_id = None\n self._app_sw_rev = None\n self._avg_hops = None\n self._avg_latency = None\n self._charge = None\n self._estimated_latency_to_mote = None\n self._hw_model = None\n self._hw_rev = None\n self._id = None\n self._join_sys_time = None\n self._last_voltage = None\n self._lost_packet_count = None\n self._mac_address = None\n self._max_current = None\n self._max_num_links = None\n self._max_num_neighbors = None\n self._need_neighbor = None\n self._num_good_neighbors = None\n self._num_joins = None\n self._num_links = None\n self._num_neighbors = None\n self._num_parents = None\n self._power_cost_rx_link = None\n self._power_cost_tx_link = None\n self._reliability = None\n self._rx_packet_count = None\n self._stack_sw_rev = None\n self._state = None\n self._state_reason = None\n self._state_sys_time = None\n self._used_current = None","def set_security(self, secobj):\n with SecurityDocument(self.cloudant_database) as sec_doc:\n # context manager saves\n for key in sec_doc:\n del sec_doc[key]\n for k, v in secobj.items():\n sec_doc[k] = v\n return self.get_security()","def __init__(__self__, *,\n enable_certificates: Optional[pulumi.Input[bool]] = None):\n if enable_certificates is not None:\n pulumi.set(__self__, \"enable_certificates\", enable_certificates)","def __init__(__self__, *,\n enable_certificates: Optional[pulumi.Input[bool]] = None):\n if enable_certificates is not None:\n pulumi.set(__self__, \"enable_certificates\", enable_certificates)","def _generate_implicit_api_resource(self):\n return ImplicitHttpApiResource().to_dict()","def generate_ipsec_conf(strongswan_obj, **kwargs):\r\n return strongswan_obj.create_ipsec_conf(**kwargs)","def get_certificate_issuance_config_output(certificate_issuance_config_id: Optional[pulumi.Input[str]] = None,\n location: Optional[pulumi.Input[str]] = None,\n project: Optional[pulumi.Input[Optional[str]]] = None,\n opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetCertificateIssuanceConfigResult]:\n ...","def __eq__(self, other):\n if not isinstance(other, TypesConsoleCertificateSettings):\n return False\n\n return self.to_dict() == other.to_dict()","def _get_kind(cls):\n return 'CredentialsModel'","def _get_config_data(self, cr, uid):\n\n model_conf = self.pool.get('customer.support.settings')\n args = [('selected', '=', True)] \n ids = model_conf.search(cr, uid, args)\n config = model_conf.browse(cr, uid, ids[0])\n\n return {\n 'tor_api_key': config.tor_api_key,\n 'tor_domain': config.tor_domain,\n 'company': config.company\n }","def cdap_settings(configs_dir):\n return config.read_model_settings(configs_dir, 'cdap.yaml')","def edit_certificate(self, certificate):\r\n return self.ssl.editObject(certificate, id=certificate['id'])","def default_configs(cls):\n config = super().default_configs()\n config.update(\n {\n \"entry_type\": \"ft.onto.base_ontology.Document\",\n \"model_name\": \"ktrapeznikov/biobert_v1.1_pubmed_squad_v2\",\n \"question\": \"Where do I live\",\n \"max_answer_len\": 15,\n \"cuda_devices\": -1,\n \"handle_impossible_answer\": False,\n }\n )\n return config","def test_user_settings_serialization(self):\n\n # Construct a json representation of a UserSettings model\n user_settings_model_json = {}\n user_settings_model_json['language'] = 'testString'\n user_settings_model_json['notification_language'] = 'testString'\n user_settings_model_json['allowed_ip_addresses'] = '32.96.110.50,172.16.254.1'\n user_settings_model_json['self_manage'] = True\n\n # Construct a model instance of UserSettings by calling from_dict on the json representation\n user_settings_model = UserSettings.from_dict(user_settings_model_json)\n assert user_settings_model != False\n\n # Construct a model instance of UserSettings by calling from_dict on the json representation\n user_settings_model_dict = UserSettings.from_dict(user_settings_model_json).__dict__\n user_settings_model2 = UserSettings(**user_settings_model_dict)\n\n # Verify the model instances are equivalent\n assert user_settings_model == user_settings_model2\n\n # Convert model instance back to dict and verify no loss of data\n user_settings_model_json2 = user_settings_model.to_dict()\n assert user_settings_model_json2 == user_settings_model_json","def __init__(self):\n self.swagger_types = {\n 'id': 'str',\n 'ticket_id': 'str',\n 'type': 'str',\n 'from_number': 'str',\n 'from_name': 'str',\n 'to_number': 'str',\n 'to_name': 'str',\n 'via_number': 'str',\n 'date_created': 'datetime',\n 'date_answered': 'datetime',\n 'date_finished': 'datetime'\n }\n\n self.attribute_map = {\n 'id': 'id',\n 'ticket_id': 'ticketId',\n 'type': 'type',\n 'from_number': 'fromNumber',\n 'from_name': 'fromName',\n 'to_number': 'toNumber',\n 'to_name': 'toName',\n 'via_number': 'viaNumber',\n 'date_created': 'dateCreated',\n 'date_answered': 'dateAnswered',\n 'date_finished': 'dateFinished'\n }\n\n self._id = None\n self._ticket_id = None\n self._type = None\n self._from_number = None\n self._from_name = None\n self._to_number = None\n self._to_name = None\n self._via_number = None\n self._date_created = None\n self._date_answered = None\n self._date_finished = None","def to_dict(self):\n result = {}\n\n for attr, _ in six.iteritems(self.swagger_types):\n value = getattr(self, attr)\n if isinstance(value, list):\n result[attr] = list(map(\n lambda x: x.to_dict() if hasattr(x, \"to_dict\") else x,\n value\n ))\n elif hasattr(value, \"to_dict\"):\n result[attr] = value.to_dict()\n elif isinstance(value, dict):\n result[attr] = dict(map(\n lambda item: (item[0], item[1].to_dict())\n if hasattr(item[1], \"to_dict\") else item,\n value.items()\n ))\n else:\n result[attr] = value\n if issubclass(AccessPolicyLoggingSettingModel, dict):\n for key, value in self.items():\n result[key] = value\n\n return result","def openapi_types():\n lazy_import()\n return {\n 'geolocation_settings': (OtoroshiModelsGeolocationSettings,), # noqa: E501\n 'alerts_emails': ([str],), # noqa: E501\n 'throttling_quota': (int,), # noqa: E501\n 'max_webhook_size': (int,), # noqa: E501\n 'max_concurrent_requests': (int,), # noqa: E501\n 'clever_settings': (dict,), # noqa: E501\n 'endless_ip_addresses': ([str],), # noqa: E501\n 'plugins': (OtoroshiScriptPluginsPlugins,), # noqa: E501\n 'kafka_config': (dict,), # noqa: E501\n 'max_logs_size': (int,), # noqa: E501\n 'proxies': (OtoroshiModelsProxies,), # noqa: E501\n 'enable_embedded_metrics': (bool,), # noqa: E501\n 'elastic_reads_config': (dict,), # noqa: E501\n 'tags': ([str],), # noqa: E501\n 'limit_concurrent_requests': (bool,), # noqa: E501\n 'use_akka_http_client': (bool,), # noqa: E501\n 'elastic_writes_configs': ([OtoroshiModelsElasticAnalyticsConfig],), # noqa: E501\n 'log_analytics_on_server': (bool,), # noqa: E501\n 'metadata': ({str: (str,)},), # noqa: E501\n 'api_read_only': (bool,), # noqa: E501\n 'back_office_auth_ref': (dict,), # noqa: E501\n 'stream_entity_only': (bool,), # noqa: E501\n 'otoroshi_id': (str,), # noqa: E501\n 'mailer_settings': (dict,), # noqa: E501\n 'lines': ([str],), # noqa: E501\n 'middle_fingers': (bool,), # noqa: E501\n 'analytics_webhooks': ([OtoroshiModelsWebhook],), # noqa: E501\n 'auto_cert': (OtoroshiModelsAutoCert,), # noqa: E501\n 'maintenance_mode': (bool,), # noqa: E501\n 'lets_encrypt_settings': (OtoroshiUtilsLetsencryptLetsEncryptSettings,), # noqa: E501\n 'snow_monkey_config': (OtoroshiModelsSnowMonkeyConfig,), # noqa: E501\n 'scripts': (OtoroshiModelsGlobalScripts,), # noqa: E501\n 'per_ip_throttling_quota': (int,), # noqa: E501\n 'use_circuit_breakers': (bool,), # noqa: E501\n 'max_http10_response_size': (int,), # noqa: E501\n 'tls_settings': (OtoroshiModelsTlsSettings,), # noqa: E501\n 'statsd_config': (dict,), # noqa: E501\n 'auto_link_to_default_group': (bool,), # noqa: E501\n 'alerts_webhooks': ([OtoroshiModelsWebhook],), # noqa: E501\n 'ip_filtering': (OtoroshiModelsIpFiltering,), # noqa: E501\n 'u2f_login_only': (bool,), # noqa: E501\n 'user_agent_settings': (OtoroshiModelsUserAgentSettings,), # noqa: E501\n }","def get_settings(self):\n settings = self.client._perform_json(\n \"GET\", \"/projects/%s/apiservices/%s/settings\" % (self.project_key, self.service_id))\n\n return DSSAPIServiceSettings(self.client, self.project_key, self.service_id, settings)","def get_spec(self):\n from schematics.types import ModelType\n spec = {\n 'id': self.name,\n 'description': self.description,\n 'addressable': self.array,\n 'required': self.required,\n }\n if self.type.has_schema:\n spec['schema'] = self.type.get_spec()\n else:\n spec.update(self.type.get_spec())\n\n return spec","def __init__(self):\n self.swagger_types = {\n 'is_waiting': 'bool',\n 'is_active': 'bool',\n 'is_acd': 'bool',\n 'is_preferred': 'bool',\n 'is_screenshare': 'bool',\n 'is_cobrowse': 'bool',\n 'is_voicemail': 'bool',\n 'is_flagged': 'bool',\n 'is_monitored': 'bool',\n 'filter_wrap_up_notes': 'bool',\n 'match_all': 'bool'\n }\n\n self.attribute_map = {\n 'is_waiting': 'isWaiting',\n 'is_active': 'isActive',\n 'is_acd': 'isAcd',\n 'is_preferred': 'isPreferred',\n 'is_screenshare': 'isScreenshare',\n 'is_cobrowse': 'isCobrowse',\n 'is_voicemail': 'isVoicemail',\n 'is_flagged': 'isFlagged',\n 'is_monitored': 'isMonitored',\n 'filter_wrap_up_notes': 'filterWrapUpNotes',\n 'match_all': 'matchAll'\n }\n\n self._is_waiting = None\n self._is_active = None\n self._is_acd = None\n self._is_preferred = None\n self._is_screenshare = None\n self._is_cobrowse = None\n self._is_voicemail = None\n self._is_flagged = None\n self._is_monitored = None\n self._filter_wrap_up_notes = None\n self._match_all = None","def grpc_settings(self) -> 'outputs.NotificationEndpointGrpcSettingsResponse':\n return pulumi.get(self, \"grpc_settings\")","def get_settings():\n return SettingCollection.build()","def create_settings_command(\n settings_cls: type[BaseCustomSettings], logger: logging.Logger | None = None\n) -> Callable:\n\n assert issubclass(settings_cls, BaseCustomSettings) # nosec\n assert settings_cls != BaseCustomSettings # nosec\n\n if logger is None:\n logger = logging.getLogger(__name__)\n\n def settings(\n as_json: bool = False,\n as_json_schema: bool = False,\n compact: bool = typer.Option(False, help=\"Print compact form\"),\n verbose: bool = False,\n show_secrets: bool = False,\n exclude_unset: bool = typer.Option(\n False,\n help=\"displays settings that were explicitly set\"\n \"This represents current config (i.e. required+ defaults overriden).\",\n ),\n ):\n \"\"\"Resolves settings and prints envfile\"\"\"\n\n if as_json_schema:\n typer.echo(settings_cls.schema_json(indent=0 if compact else 2))\n return\n\n try:\n settings_obj = settings_cls.create_from_envs()\n\n except ValidationError as err:\n settings_schema = settings_cls.schema_json(indent=2)\n\n assert logger is not None # nosec\n logger.error(\n \"Invalid settings. \"\n \"Typically this is due to an environment variable missing or misspelled :\\n%s\",\n \"\\n\".join(\n [\n HEADER_STR.format(\"detail\"),\n str(err),\n HEADER_STR.format(\"environment variables\"),\n pformat(\n {\n k: v\n for k, v in dict(os.environ).items()\n if k.upper() == k\n }\n ),\n HEADER_STR.format(\"json-schema\"),\n settings_schema,\n ]\n ),\n exc_info=False,\n )\n raise\n\n pydantic_export_options: dict[str, Any] = {\"exclude_unset\": exclude_unset}\n if show_secrets:\n # NOTE: this option is for json-only\n pydantic_export_options[\"encoder\"] = create_json_encoder_wo_secrets(\n settings_cls\n )\n\n if as_json:\n print_as_json(settings_obj, compact=compact, **pydantic_export_options)\n else:\n print_as_envfile(\n settings_obj,\n compact=compact,\n verbose=verbose,\n show_secrets=show_secrets,\n **pydantic_export_options,\n )\n\n return settings","def test_settingmodel_init():\n SettingsModel()","def get_report_config(self, type: Type, id: str) -> Dict[str, Any]:\n return self.get_document(type, id)","def test_create_hyperflex_ucsm_config_policy(self):\n pass","def __init__(self, **kwargs):\n self.swagger_types = {\n 'key': 'str',\n 'display_name': 'str',\n 'description': 'str',\n 'glossary_key': 'str',\n 'parent_term_key': 'str',\n 'is_allowed_to_have_child_terms': 'bool',\n 'path': 'str',\n 'lifecycle_state': 'str',\n 'time_created': 'datetime',\n 'time_updated': 'datetime',\n 'created_by_id': 'str',\n 'updated_by_id': 'str',\n 'owner': 'str',\n 'workflow_status': 'str',\n 'uri': 'str',\n 'associated_object_count': 'int',\n 'associated_objects': 'list[TermAssociatedObject]'\n }\n\n self.attribute_map = {\n 'key': 'key',\n 'display_name': 'displayName',\n 'description': 'description',\n 'glossary_key': 'glossaryKey',\n 'parent_term_key': 'parentTermKey',\n 'is_allowed_to_have_child_terms': 'isAllowedToHaveChildTerms',\n 'path': 'path',\n 'lifecycle_state': 'lifecycleState',\n 'time_created': 'timeCreated',\n 'time_updated': 'timeUpdated',\n 'created_by_id': 'createdById',\n 'updated_by_id': 'updatedById',\n 'owner': 'owner',\n 'workflow_status': 'workflowStatus',\n 'uri': 'uri',\n 'associated_object_count': 'associatedObjectCount',\n 'associated_objects': 'associatedObjects'\n }\n\n self._key = None\n self._display_name = None\n self._description = None\n self._glossary_key = None\n self._parent_term_key = None\n self._is_allowed_to_have_child_terms = None\n self._path = None\n self._lifecycle_state = None\n self._time_created = None\n self._time_updated = None\n self._created_by_id = None\n self._updated_by_id = None\n self._owner = None\n self._workflow_status = None\n self._uri = None\n self._associated_object_count = None\n self._associated_objects = None","def lic_type():\n return VocabularyType.create(id='licenses', pid_type='lic')","async def update_trace_settings(\n self,\n model_name: str = ...,\n settings: dict[str, t.Any] = ...,\n headers: dict[str, t.Any] = ...,\n as_json: t.Literal[False] = ...,\n ) -> service_pb2.TraceSettingResponse:\n ...","def custom_openapi() -> Dict:\n if app.openapi_schema:\n return app.openapi_schema\n openapi_schema = get_openapi(\n title=\"The GenomicMedLab Cool Seq Tool\",\n version=__version__,\n description=\"Common Operations On Lots-of Sequences Tool.\",\n routes=app.routes\n )\n\n openapi_schema[\"info\"][\"contact\"] = {\n \"name\": \"Alex H. Wagner\",\n \"email\": \"Alex.Wagner@nationwidechildrens.org\",\n \"url\": \"https://www.nationwidechildrens.org/specialties/institute-for-genomic-medicine/research-labs/wagner-lab\" # noqa: E501\n }\n app.openapi_schema = openapi_schema\n return app.openapi_schema","def init_api(settings):\n dirname = os.path.dirname(__file__)\n while len(dirname) > 1:\n p = os.path.join(dirname, 'cacerts.txt')\n\n if os.path.exists(p):\n cclib.CA_CERTS = p\n break\n\n dirname = os.path.dirname(dirname)\n return cclib.API(token=read_tokenfile(settings),\n url=settings.api_url,\n token_source_url=settings.token_source_url,\n register_addon_url=settings.register_addon_url,\n encode_email=settings.encode_email)","def __init__(self, jsondict=None, strict=True):\n \n self.description = None\n \"\"\" Description of capability.\n List of `CodeableConcept` items (represented as `dict` in JSON). \"\"\"\n \n self.type = None\n \"\"\" Type of capability.\n Type `CodeableConcept` (represented as `dict` in JSON). \"\"\"\n \n super(DeviceDefinitionCapability, self).__init__(jsondict=jsondict, strict=strict)","async def getConfigurationByType(self, type=None):\n payload = {}\n \n if type:\n payload[\"type\"] = type\n \n\n # Parameter validation\n schema = CatalogValidator.getConfigurationByType()\n schema.dump(schema.load(payload))\n \n\n url_with_params = await create_url_with_params(self._conf.domain, f\"/service/platform/catalog/v1.0/company/{self._conf.companyId}/application/{self.applicationId}/product-configuration/{type}/\", \"\"\"{\"required\":[{\"in\":\"path\",\"name\":\"company_id\",\"description\":\"A `company_id` is a unique identifier for a particular seller account.\",\"schema\":{\"type\":\"string\"},\"required\":true},{\"in\":\"path\",\"name\":\"application_id\",\"description\":\"A `application_id` is a unique identifier for a particular sale channel.\",\"schema\":{\"type\":\"string\"},\"required\":true},{\"in\":\"path\",\"name\":\"type\",\"description\":\"type can be brands, categories etc.\",\"schema\":{\"type\":\"string\"},\"required\":true}],\"optional\":[],\"query\":[],\"headers\":[],\"path\":[{\"in\":\"path\",\"name\":\"company_id\",\"description\":\"A `company_id` is a unique identifier for a particular seller account.\",\"schema\":{\"type\":\"string\"},\"required\":true},{\"in\":\"path\",\"name\":\"application_id\",\"description\":\"A `application_id` is a unique identifier for a particular sale channel.\",\"schema\":{\"type\":\"string\"},\"required\":true},{\"in\":\"path\",\"name\":\"type\",\"description\":\"type can be brands, categories etc.\",\"schema\":{\"type\":\"string\"},\"required\":true}]}\"\"\", type=type)\n query_string = await create_query_string(type=type)\n headers = {\n \"Authorization\": \"Bearer \" + await self._conf.getAccessToken()\n }\n for h in self._conf.extraHeaders:\n headers.update(h)\n exclude_headers = []\n for key, val in headers.items():\n if not key.startswith(\"x-fp-\"):\n exclude_headers.append(key)\n return await AiohttpHelper().aiohttp_request(\"GET\", url_with_params, headers=get_headers_with_signature(self._conf.domain, \"get\", await create_url_without_domain(f\"/service/platform/catalog/v1.0/company/{self._conf.companyId}/application/{self.applicationId}/product-configuration/{type}/\", type=type), query_string, headers, \"\", exclude_headers=exclude_headers), data=\"\")","def credential_list():\n rows = safeisland.list_certificates()\n certs = []\n for row in rows:\n# certs.append(row[\"cert\"])\n certs.append({\"uuid\": row[\"uuid\"], \"cert\": row[\"cert\"]})\n\n return {\"payload\": certs}","def __init__(__self__, *,\n addon_configs: Optional[pulumi.Input[Mapping[str, Any]]] = None,\n api_metadata_properties: Optional[pulumi.Input['GatewayApiMetadataPropertiesArgs']] = None,\n apm_types: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ApmType']]]]] = None,\n client_auth: Optional[pulumi.Input['GatewayPropertiesClientAuthArgs']] = None,\n cors_properties: Optional[pulumi.Input['GatewayCorsPropertiesArgs']] = None,\n environment_variables: Optional[pulumi.Input['GatewayPropertiesEnvironmentVariablesArgs']] = None,\n https_only: Optional[pulumi.Input[bool]] = None,\n public: Optional[pulumi.Input[bool]] = None,\n resource_requests: Optional[pulumi.Input['GatewayResourceRequestsArgs']] = None,\n sso_properties: Optional[pulumi.Input['SsoPropertiesArgs']] = None):\n if addon_configs is not None:\n pulumi.set(__self__, \"addon_configs\", addon_configs)\n if api_metadata_properties is not None:\n pulumi.set(__self__, \"api_metadata_properties\", api_metadata_properties)\n if apm_types is not None:\n pulumi.set(__self__, \"apm_types\", apm_types)\n if client_auth is not None:\n pulumi.set(__self__, \"client_auth\", client_auth)\n if cors_properties is not None:\n pulumi.set(__self__, \"cors_properties\", cors_properties)\n if environment_variables is not None:\n pulumi.set(__self__, \"environment_variables\", environment_variables)\n if https_only is None:\n https_only = False\n if https_only is not None:\n pulumi.set(__self__, \"https_only\", https_only)\n if public is None:\n public = False\n if public is not None:\n pulumi.set(__self__, \"public\", public)\n if resource_requests is not None:\n pulumi.set(__self__, \"resource_requests\", resource_requests)\n if sso_properties is not None:\n pulumi.set(__self__, \"sso_properties\", sso_properties)","def __init__(self, config):\n super().__init__(config)\n self.collector_host = config.get(\"collector_host\")\n self.schedds = config.get(\"schedds\", [None])\n self.condor_config = config.get(\"condor_config\")\n self.constraint = config.get(\"constraint\", True)\n self.classad_attrs = config.get(\"classad_attrs\")\n self.correction_map = config.get(\"correction_map\")","def _model_structure(self):\n self.model_structure = {\n 'title': str,\n 'description': str,\n 'tags': [str],\n 'references': [str],\n 'categories': [int],\n 'authors': [dict],\n 'defined_type': str,\n 'funding': str,\n 'license': str\n }","def __init__(self):\n self.swagger_types = {\n 'id': 'str',\n 'name': 'str',\n 'channel_id': 'str',\n 'channel_secret': 'str',\n 'switcher_secret': 'str',\n 'service_code': 'str',\n 'self_uri': 'str'\n }\n\n self.attribute_map = {\n 'id': 'id',\n 'name': 'name',\n 'channel_id': 'channelId',\n 'channel_secret': 'channelSecret',\n 'switcher_secret': 'switcherSecret',\n 'service_code': 'serviceCode',\n 'self_uri': 'selfUri'\n }\n\n self._id = None\n self._name = None\n self._channel_id = None\n self._channel_secret = None\n self._switcher_secret = None\n self._service_code = None\n self._self_uri = None","def __init__(__self__,\n resource_name: str,\n args: ServerCertificateArgs,\n opts: Optional[pulumi.ResourceOptions] = None):\n ...","def CreateOrUpdateAWSSettings(self, body):\n # [POST] https://assets.falcon.crowdstrike.com/support/api/swagger.html#/cloud-connect-aws/CreateOrUpdateAWSSettings\n FULL_URL = self.base_url+'/cloud-connect-aws/entities/settings/v1'\n HEADERS = self.headers\n BODY = body\n result = self.Result()\n try:\n response = requests.request(\"POST\", FULL_URL, json=BODY, headers=HEADERS, verify=False)\n returned = result(response.status_code, response.headers, response.json())\n except Exception as e:\n returned = result(500, {}, str(e))\n \n return returned","def __init__(self):\n self.swagger_types = {\n 'id_template_notificacao': 'int',\n 'destinatarios': 'list[str]',\n 'anexos': 'list[AnexoNotificacaoEmailRequest]',\n 'parametros_conteudo': 'dict(str, object)'\n }\n\n self.attribute_map = {\n 'id_template_notificacao': 'idTemplateNotificacao',\n 'destinatarios': 'destinatarios',\n 'anexos': 'anexos',\n 'parametros_conteudo': 'parametrosConteudo'\n }\n\n self._id_template_notificacao = None\n self._destinatarios = None\n self._anexos = None\n self._parametros_conteudo = None","def test_create_hyperflex_vcenter_config_policy(self):\n pass","def settings(self):\n return {}","def to_dict(self):\n result = {}\n\n for attr, _ in six.iteritems(self.swagger_types):\n value = getattr(self, attr)\n if isinstance(value, list):\n result[attr] = list(map(\n lambda x: x.to_dict() if hasattr(x, \"to_dict\") else x,\n value\n ))\n elif hasattr(value, \"to_dict\"):\n result[attr] = value.to_dict()\n elif isinstance(value, dict):\n result[attr] = dict(map(\n lambda item: (item[0], item[1].to_dict())\n if hasattr(item[1], \"to_dict\") else item,\n value.items()\n ))\n else:\n result[attr] = value\n if issubclass(ChanPlanExplicit, dict):\n for key, value in self.items():\n result[key] = value\n\n return result","def test_get_rule_settings(self):\n # Basic passing test\n rule_settings_params = {'agency_code': '097', 'file': 'B'}\n response = self.app.get('/v1/rule_settings/', rule_settings_params, headers={'x-session-id': self.session_id})\n\n self.assertEqual(response.status_code, 200)\n assert {'errors', 'warnings'} <= set(response.json.keys())","def __init__(__self__, *,\n auth_type: pulumi.Input[str],\n ca_cert_resource_id: Optional[pulumi.Input[str]] = None):\n pulumi.set(__self__, \"auth_type\", 'Public')\n if ca_cert_resource_id is not None:\n pulumi.set(__self__, \"ca_cert_resource_id\", ca_cert_resource_id)","def __init__(self):\n super(sppasAnnotationsSettings, self).__init__()\n self.__dict__ = dict(\n error=-1,\n ok=0,\n warning=1,\n ignore=2,\n info=3,\n\n extension=\".xra\",\n\n # all the types of the annotations implemented into SPPAS\n types=(\"STANDALONE\", \"SPEAKER\", \"INTERACTION\"),\n\n # standard iso639-3 code for an undetermined language.\n UNDETERMINED=\"und\"\n\n )","def test_object_model_with_ref_props(self):\n from petstore_api.model import object_model_with_ref_props\n endpoint = self.api.object_model_with_ref_props\n assert endpoint.openapi_types['body'] == (object_model_with_ref_props.ObjectModelWithRefProps,)\n assert endpoint.settings['response_type'] == (object_model_with_ref_props.ObjectModelWithRefProps,)","def to_dict(self):\n result = {}\n\n for attr, _ in six.iteritems(self.swagger_types):\n value = getattr(self, attr)\n if isinstance(value, list):\n result[attr] = list(\n map(lambda x: x.to_dict() if hasattr(x, \"to_dict\") else x, value)\n )\n elif hasattr(value, \"to_dict\"):\n result[attr] = value.to_dict()\n elif isinstance(value, dict):\n result[attr] = dict(\n map(\n lambda item: (item[0], item[1].to_dict())\n if hasattr(item[1], \"to_dict\")\n else item,\n value.items(),\n )\n )\n else:\n result[attr] = value\n if issubclass(FtsSftpSettings, dict):\n for key, value in self.items():\n result[key] = value\n\n return result","def __init__(self, settings):\n self._settings = settings","def __init__(__self__, *,\n label: pulumi.Input[str],\n type: pulumi.Input[str],\n accessibility_error_redirect_url: Optional[pulumi.Input[str]] = None,\n accessibility_login_redirect_url: Optional[pulumi.Input[str]] = None,\n accessibility_self_service: Optional[pulumi.Input[bool]] = None,\n admin_note: Optional[pulumi.Input[str]] = None,\n app_links_json: Optional[pulumi.Input[str]] = None,\n app_settings_json: Optional[pulumi.Input[str]] = None,\n authentication_policy: Optional[pulumi.Input[str]] = None,\n auto_key_rotation: Optional[pulumi.Input[bool]] = None,\n auto_submit_toolbar: Optional[pulumi.Input[bool]] = None,\n client_basic_secret: Optional[pulumi.Input[str]] = None,\n client_id: Optional[pulumi.Input[str]] = None,\n client_uri: Optional[pulumi.Input[str]] = None,\n consent_method: Optional[pulumi.Input[str]] = None,\n enduser_note: Optional[pulumi.Input[str]] = None,\n grant_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n groups_claim: Optional[pulumi.Input['OAuthGroupsClaimArgs']] = None,\n hide_ios: Optional[pulumi.Input[bool]] = None,\n hide_web: Optional[pulumi.Input[bool]] = None,\n implicit_assignment: Optional[pulumi.Input[bool]] = None,\n issuer_mode: Optional[pulumi.Input[str]] = None,\n jwks: Optional[pulumi.Input[Sequence[pulumi.Input['OAuthJwkArgs']]]] = None,\n jwks_uri: Optional[pulumi.Input[str]] = None,\n login_mode: Optional[pulumi.Input[str]] = None,\n login_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n login_uri: Optional[pulumi.Input[str]] = None,\n logo: Optional[pulumi.Input[str]] = None,\n logo_uri: Optional[pulumi.Input[str]] = None,\n omit_secret: Optional[pulumi.Input[bool]] = None,\n pkce_required: Optional[pulumi.Input[bool]] = None,\n policy_uri: Optional[pulumi.Input[str]] = None,\n post_logout_redirect_uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n profile: Optional[pulumi.Input[str]] = None,\n redirect_uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n refresh_token_leeway: Optional[pulumi.Input[int]] = None,\n refresh_token_rotation: Optional[pulumi.Input[str]] = None,\n response_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n status: Optional[pulumi.Input[str]] = None,\n token_endpoint_auth_method: Optional[pulumi.Input[str]] = None,\n tos_uri: Optional[pulumi.Input[str]] = None,\n user_name_template: Optional[pulumi.Input[str]] = None,\n user_name_template_push_status: Optional[pulumi.Input[str]] = None,\n user_name_template_suffix: Optional[pulumi.Input[str]] = None,\n user_name_template_type: Optional[pulumi.Input[str]] = None,\n wildcard_redirect: Optional[pulumi.Input[str]] = None):\n pulumi.set(__self__, \"label\", label)\n pulumi.set(__self__, \"type\", type)\n if accessibility_error_redirect_url is not None:\n pulumi.set(__self__, \"accessibility_error_redirect_url\", accessibility_error_redirect_url)\n if accessibility_login_redirect_url is not None:\n pulumi.set(__self__, \"accessibility_login_redirect_url\", accessibility_login_redirect_url)\n if accessibility_self_service is not None:\n pulumi.set(__self__, \"accessibility_self_service\", accessibility_self_service)\n if admin_note is not None:\n pulumi.set(__self__, \"admin_note\", admin_note)\n if app_links_json is not None:\n pulumi.set(__self__, \"app_links_json\", app_links_json)\n if app_settings_json is not None:\n pulumi.set(__self__, \"app_settings_json\", app_settings_json)\n if authentication_policy is not None:\n pulumi.set(__self__, \"authentication_policy\", authentication_policy)\n if auto_key_rotation is not None:\n pulumi.set(__self__, \"auto_key_rotation\", auto_key_rotation)\n if auto_submit_toolbar is not None:\n pulumi.set(__self__, \"auto_submit_toolbar\", auto_submit_toolbar)\n if client_basic_secret is not None:\n pulumi.set(__self__, \"client_basic_secret\", client_basic_secret)\n if client_id is not None:\n pulumi.set(__self__, \"client_id\", client_id)\n if client_uri is not None:\n pulumi.set(__self__, \"client_uri\", client_uri)\n if consent_method is not None:\n pulumi.set(__self__, \"consent_method\", consent_method)\n if enduser_note is not None:\n pulumi.set(__self__, \"enduser_note\", enduser_note)\n if grant_types is not None:\n pulumi.set(__self__, \"grant_types\", grant_types)\n if groups_claim is not None:\n pulumi.set(__self__, \"groups_claim\", groups_claim)\n if hide_ios is not None:\n pulumi.set(__self__, \"hide_ios\", hide_ios)\n if hide_web is not None:\n pulumi.set(__self__, \"hide_web\", hide_web)\n if implicit_assignment is not None:\n pulumi.set(__self__, \"implicit_assignment\", implicit_assignment)\n if issuer_mode is not None:\n pulumi.set(__self__, \"issuer_mode\", issuer_mode)\n if jwks is not None:\n pulumi.set(__self__, \"jwks\", jwks)\n if jwks_uri is not None:\n pulumi.set(__self__, \"jwks_uri\", jwks_uri)\n if login_mode is not None:\n pulumi.set(__self__, \"login_mode\", login_mode)\n if login_scopes is not None:\n pulumi.set(__self__, \"login_scopes\", login_scopes)\n if login_uri is not None:\n pulumi.set(__self__, \"login_uri\", login_uri)\n if logo is not None:\n pulumi.set(__self__, \"logo\", logo)\n if logo_uri is not None:\n pulumi.set(__self__, \"logo_uri\", logo_uri)\n if omit_secret is not None:\n pulumi.set(__self__, \"omit_secret\", omit_secret)\n if pkce_required is not None:\n pulumi.set(__self__, \"pkce_required\", pkce_required)\n if policy_uri is not None:\n pulumi.set(__self__, \"policy_uri\", policy_uri)\n if post_logout_redirect_uris is not None:\n pulumi.set(__self__, \"post_logout_redirect_uris\", post_logout_redirect_uris)\n if profile is not None:\n pulumi.set(__self__, \"profile\", profile)\n if redirect_uris is not None:\n pulumi.set(__self__, \"redirect_uris\", redirect_uris)\n if refresh_token_leeway is not None:\n pulumi.set(__self__, \"refresh_token_leeway\", refresh_token_leeway)\n if refresh_token_rotation is not None:\n pulumi.set(__self__, \"refresh_token_rotation\", refresh_token_rotation)\n if response_types is not None:\n pulumi.set(__self__, \"response_types\", response_types)\n if status is not None:\n pulumi.set(__self__, \"status\", status)\n if token_endpoint_auth_method is not None:\n pulumi.set(__self__, \"token_endpoint_auth_method\", token_endpoint_auth_method)\n if tos_uri is not None:\n pulumi.set(__self__, \"tos_uri\", tos_uri)\n if user_name_template is not None:\n pulumi.set(__self__, \"user_name_template\", user_name_template)\n if user_name_template_push_status is not None:\n pulumi.set(__self__, \"user_name_template_push_status\", user_name_template_push_status)\n if user_name_template_suffix is not None:\n pulumi.set(__self__, \"user_name_template_suffix\", user_name_template_suffix)\n if user_name_template_type is not None:\n pulumi.set(__self__, \"user_name_template_type\", user_name_template_type)\n if wildcard_redirect is not None:\n pulumi.set(__self__, \"wildcard_redirect\", wildcard_redirect)","def openapi_types():\n return {\n \"account\": (str,), # noqa: E501\n \"address_city\": (str,), # noqa: E501\n \"address_country\": (str,), # noqa: E501\n \"address_line1\": (str,), # noqa: E501\n \"address_line1_check\": (str,), # noqa: E501\n \"address_line2\": (str,), # noqa: E501\n \"address_state\": (str,), # noqa: E501\n \"address_zip\": (str,), # noqa: E501\n \"address_zip_check\": (str,), # noqa: E501\n \"available_payout_methods\": ([str],), # noqa: E501\n \"brand\": (str,), # noqa: E501\n \"country\": (str,), # noqa: E501\n \"currency\": (str,), # noqa: E501\n \"customer\": (str,), # noqa: E501\n \"cvc_check\": (str,), # noqa: E501\n \"default_for_currency\": (bool,), # noqa: E501\n \"description\": (str,), # noqa: E501\n \"dynamic_last4\": (str,), # noqa: E501\n \"exp_month\": (int,), # noqa: E501\n \"exp_year\": (int,), # noqa: E501\n \"fingerprint\": (str,), # noqa: E501\n \"funding\": (str,), # noqa: E501\n \"id\": (str,), # noqa: E501\n \"iin\": (str,), # noqa: E501\n \"instance_url\": (str,), # noqa: E501\n \"issuer\": (str,), # noqa: E501\n \"last4\": (str,), # noqa: E501\n \"metadata\": ({str: (str,)},), # noqa: E501\n \"name\": (str,), # noqa: E501\n \"object\": (str,), # noqa: E501\n \"recipient\": (str,), # noqa: E501\n \"status\": (str,), # noqa: E501\n \"three_d_secure\": (three_d_secure.ThreeDSecure,), # noqa: E501\n \"tokenization_method\": (str,), # noqa: E501\n \"type\": (str,), # noqa: E501\n }","def client_settings():\n return CLIENT_SETTINGS","def __init__(self, com_adobe_aem_screens_player_pingfrequency: ConfigNodePropertyInteger=None, com_adobe_aem_screens_device_pasword_specialchars: ConfigNodePropertyString=None, com_adobe_aem_screens_device_pasword_minlowercasechars: ConfigNodePropertyInteger=None, com_adobe_aem_screens_device_pasword_minuppercasechars: ConfigNodePropertyInteger=None, com_adobe_aem_screens_device_pasword_minnumberchars: ConfigNodePropertyInteger=None, com_adobe_aem_screens_device_pasword_minspecialchars: ConfigNodePropertyInteger=None, com_adobe_aem_screens_device_pasword_minlength: ConfigNodePropertyInteger=None): # noqa: E501\n self.openapi_types = {\n 'com_adobe_aem_screens_player_pingfrequency': ConfigNodePropertyInteger,\n 'com_adobe_aem_screens_device_pasword_specialchars': ConfigNodePropertyString,\n 'com_adobe_aem_screens_device_pasword_minlowercasechars': ConfigNodePropertyInteger,\n 'com_adobe_aem_screens_device_pasword_minuppercasechars': ConfigNodePropertyInteger,\n 'com_adobe_aem_screens_device_pasword_minnumberchars': ConfigNodePropertyInteger,\n 'com_adobe_aem_screens_device_pasword_minspecialchars': ConfigNodePropertyInteger,\n 'com_adobe_aem_screens_device_pasword_minlength': ConfigNodePropertyInteger\n }\n\n self.attribute_map = {\n 'com_adobe_aem_screens_player_pingfrequency': 'com.adobe.aem.screens.player.pingfrequency',\n 'com_adobe_aem_screens_device_pasword_specialchars': 'com.adobe.aem.screens.device.pasword.specialchars',\n 'com_adobe_aem_screens_device_pasword_minlowercasechars': 'com.adobe.aem.screens.device.pasword.minlowercasechars',\n 'com_adobe_aem_screens_device_pasword_minuppercasechars': 'com.adobe.aem.screens.device.pasword.minuppercasechars',\n 'com_adobe_aem_screens_device_pasword_minnumberchars': 'com.adobe.aem.screens.device.pasword.minnumberchars',\n 'com_adobe_aem_screens_device_pasword_minspecialchars': 'com.adobe.aem.screens.device.pasword.minspecialchars',\n 'com_adobe_aem_screens_device_pasword_minlength': 'com.adobe.aem.screens.device.pasword.minlength'\n }\n\n self._com_adobe_aem_screens_player_pingfrequency = com_adobe_aem_screens_player_pingfrequency\n self._com_adobe_aem_screens_device_pasword_specialchars = com_adobe_aem_screens_device_pasword_specialchars\n self._com_adobe_aem_screens_device_pasword_minlowercasechars = com_adobe_aem_screens_device_pasword_minlowercasechars\n self._com_adobe_aem_screens_device_pasword_minuppercasechars = com_adobe_aem_screens_device_pasword_minuppercasechars\n self._com_adobe_aem_screens_device_pasword_minnumberchars = com_adobe_aem_screens_device_pasword_minnumberchars\n self._com_adobe_aem_screens_device_pasword_minspecialchars = com_adobe_aem_screens_device_pasword_minspecialchars\n self._com_adobe_aem_screens_device_pasword_minlength = com_adobe_aem_screens_device_pasword_minlength","def SecurityPolicyFromFile(input_file, messages, file_format):\n\n if file_format == 'yaml':\n parsed_security_policy = yaml.load(input_file)\n else:\n try:\n parsed_security_policy = json.load(input_file)\n except ValueError as e:\n raise exceptions.BadFileException('Error parsing JSON: {0}'.format(\n six.text_type(e)))\n\n security_policy = messages.SecurityPolicy()\n if 'description' in parsed_security_policy:\n security_policy.description = parsed_security_policy['description']\n if 'fingerprint' in parsed_security_policy:\n security_policy.fingerprint = base64.urlsafe_b64decode(\n parsed_security_policy['fingerprint'].encode('ascii'))\n if 'type' in parsed_security_policy:\n security_policy.type = (\n messages.SecurityPolicy.TypeValueValuesEnum(\n parsed_security_policy['type']))\n if 'cloudArmorConfig' in parsed_security_policy:\n security_policy.cloudArmorConfig = messages.SecurityPolicyCloudArmorConfig(\n enableMl=parsed_security_policy['cloudArmorConfig']['enableMl'])\n if 'adaptiveProtectionConfig' in parsed_security_policy:\n security_policy.adaptiveProtectionConfig = (\n messages.SecurityPolicyAdaptiveProtectionConfig(\n layer7DdosDefenseConfig=messages\n .SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig(\n enable=parsed_security_policy['adaptiveProtectionConfig']\n ['layer7DdosDefenseConfig']['enable']),))\n if 'autoDeployConfig' in parsed_security_policy['adaptiveProtectionConfig']:\n security_policy.adaptiveProtectionConfig.autoDeployConfig = (\n messages.SecurityPolicyAdaptiveProtectionConfigAutoDeployConfig())\n if 'loadThreshold' in parsed_security_policy['adaptiveProtectionConfig'][\n 'autoDeployConfig']:\n security_policy.adaptiveProtectionConfig.autoDeployConfig.loadThreshold = (\n parsed_security_policy['adaptiveProtectionConfig']\n ['autoDeployConfig']['loadThreshold'])\n if 'confidenceThreshold' in parsed_security_policy[\n 'adaptiveProtectionConfig']['autoDeployConfig']:\n security_policy.adaptiveProtectionConfig.autoDeployConfig.confidenceThreshold = (\n parsed_security_policy['adaptiveProtectionConfig']\n ['autoDeployConfig']['confidenceThreshold'])\n if 'impactedBaselineThreshold' in parsed_security_policy[\n 'adaptiveProtectionConfig']['autoDeployConfig']:\n security_policy.adaptiveProtectionConfig.autoDeployConfig.impactedBaselineThreshold = (\n parsed_security_policy['adaptiveProtectionConfig']\n ['autoDeployConfig']['impactedBaselineThreshold'])\n if 'expirationSec' in parsed_security_policy['adaptiveProtectionConfig'][\n 'autoDeployConfig']:\n security_policy.adaptiveProtectionConfig.autoDeployConfig.expirationSec = (\n parsed_security_policy['adaptiveProtectionConfig']\n ['autoDeployConfig']['expirationSec'])\n if 'ruleVisibility' in parsed_security_policy['adaptiveProtectionConfig'][\n 'layer7DdosDefenseConfig']:\n security_policy.adaptiveProtectionConfig.layer7DdosDefenseConfig.ruleVisibility = (\n messages.SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig\n .RuleVisibilityValueValuesEnum(\n parsed_security_policy['adaptiveProtectionConfig']\n ['layer7DdosDefenseConfig']['ruleVisibility']))\n if 'advancedOptionsConfig' in parsed_security_policy:\n advanced_options_config = parsed_security_policy['advancedOptionsConfig']\n security_policy.advancedOptionsConfig = (\n messages.SecurityPolicyAdvancedOptionsConfig())\n if 'jsonParsing' in advanced_options_config:\n security_policy.advancedOptionsConfig.jsonParsing = (\n messages.SecurityPolicyAdvancedOptionsConfig\n .JsonParsingValueValuesEnum(\n advanced_options_config['jsonParsing']))\n if 'jsonCustomConfig' in advanced_options_config:\n security_policy.advancedOptionsConfig.jsonCustomConfig = (\n messages.SecurityPolicyAdvancedOptionsConfigJsonCustomConfig(\n contentTypes=advanced_options_config\n ['jsonCustomConfig'].get('contentTypes', [])))\n if 'logLevel' in advanced_options_config:\n security_policy.advancedOptionsConfig.logLevel = (\n messages.SecurityPolicyAdvancedOptionsConfig.LogLevelValueValuesEnum(\n advanced_options_config['logLevel']))\n if 'userIpRequestHeaders' in advanced_options_config:\n security_policy.advancedOptionsConfig.userIpRequestHeaders = (\n advanced_options_config['userIpRequestHeaders'])\n if 'ddosProtectionConfig' in parsed_security_policy:\n security_policy.ddosProtectionConfig = (\n messages.SecurityPolicyDdosProtectionConfig(\n ddosProtection=messages.SecurityPolicyDdosProtectionConfig\n .DdosProtectionValueValuesEnum(\n parsed_security_policy['ddosProtectionConfig']\n ['ddosProtection'])))\n if 'recaptchaOptionsConfig' in parsed_security_policy:\n security_policy.recaptchaOptionsConfig = (\n messages.SecurityPolicyRecaptchaOptionsConfig())\n if 'redirectSiteKey' in parsed_security_policy['recaptchaOptionsConfig']:\n security_policy.recaptchaOptionsConfig.redirectSiteKey = (\n parsed_security_policy['recaptchaOptionsConfig']['redirectSiteKey'])\n\n if 'userDefinedFields' in parsed_security_policy:\n user_defined_fields = []\n for udf in parsed_security_policy['userDefinedFields']:\n user_defined_field = messages.SecurityPolicyUserDefinedField()\n user_defined_field.name = udf['name']\n user_defined_field.base = (\n messages.SecurityPolicyUserDefinedField.BaseValueValuesEnum(\n udf['base']\n )\n )\n user_defined_field.offset = udf['offset']\n user_defined_field.size = udf['size']\n if 'mask' in udf:\n user_defined_field.mask = udf['mask']\n user_defined_fields.append(user_defined_field)\n security_policy.userDefinedFields = user_defined_fields\n\n rules = []\n for rule in parsed_security_policy['rules']:\n security_policy_rule = messages.SecurityPolicyRule()\n security_policy_rule.action = rule['action']\n if 'description' in rule:\n security_policy_rule.description = rule['description']\n if 'match' in rule:\n match = messages.SecurityPolicyRuleMatcher()\n if 'versionedExpr' in rule['match']:\n match.versionedExpr = ConvertToEnum(\n rule['match']['versionedExpr'], messages\n )\n if 'expr' in rule['match']:\n match.expr = messages.Expr(\n expression=rule['match']['expr']['expression']\n )\n if 'exprOptions' in rule['match']:\n expr_options = messages.SecurityPolicyRuleMatcherExprOptions()\n if 'recaptchaOptions' in rule['match']['exprOptions']:\n expr_options.recaptchaOptions = (\n messages.SecurityPolicyRuleMatcherExprOptionsRecaptchaOptions(\n actionTokenSiteKeys=rule['match']['exprOptions'][\n 'recaptchaOptions'\n ].get('actionTokenSiteKeys', []),\n sessionTokenSiteKeys=rule['match']['exprOptions'][\n 'recaptchaOptions'\n ].get('sessionTokenSiteKeys', []),\n )\n )\n match.exprOptions = expr_options\n if 'config' in rule['match']:\n if 'srcIpRanges' in rule['match']['config']:\n match.config = messages.SecurityPolicyRuleMatcherConfig(\n srcIpRanges=rule['match']['config']['srcIpRanges']\n )\n security_policy_rule.match = match\n if 'networkMatch' in rule:\n network_match = messages.SecurityPolicyRuleNetworkMatcher()\n if 'userDefinedFields' in rule['networkMatch']:\n user_defined_fields = []\n for udf in rule['networkMatch']['userDefinedFields']:\n user_defined_field_match = (\n messages.SecurityPolicyRuleNetworkMatcherUserDefinedFieldMatch()\n )\n user_defined_field_match.name = udf['name']\n user_defined_field_match.values = udf['values']\n user_defined_fields.append(user_defined_field_match)\n network_match.userDefinedFields = user_defined_fields\n if 'srcIpRanges' in rule['networkMatch']:\n network_match.srcIpRanges = rule['networkMatch']['srcIpRanges']\n if 'destIpRanges' in rule['networkMatch']:\n network_match.destIpRanges = rule['networkMatch']['destIpRanges']\n if 'ipProtocols' in rule['networkMatch']:\n network_match.ipProtocols = rule['networkMatch']['ipProtocols']\n if 'srcPorts' in rule['networkMatch']:\n network_match.srcPorts = rule['networkMatch']['srcPorts']\n if 'destPorts' in rule['networkMatch']:\n network_match.destPorts = rule['networkMatch']['destPorts']\n if 'srcRegionCodes' in rule['networkMatch']:\n network_match.srcRegionCodes = rule['networkMatch']['srcRegionCodes']\n if 'srcAsns' in rule['networkMatch']:\n network_match.srcAsns = rule['networkMatch']['srcAsns']\n security_policy_rule.networkMatch = network_match\n security_policy_rule.priority = int(rule['priority'])\n if 'preview' in rule:\n security_policy_rule.preview = rule['preview']\n rules.append(security_policy_rule)\n if 'redirectTarget' in rule:\n security_policy_rule.redirectTarget = rule['redirectTarget']\n if 'ruleNumber' in rule:\n security_policy_rule.ruleNumber = int(rule['ruleNumber'])\n if 'redirectOptions' in rule:\n redirect_options = messages.SecurityPolicyRuleRedirectOptions()\n if 'type' in rule['redirectOptions']:\n redirect_options.type = (\n messages.SecurityPolicyRuleRedirectOptions.TypeValueValuesEnum(\n rule['redirectOptions']['type']))\n if 'target' in rule['redirectOptions']:\n redirect_options.target = rule['redirectOptions']['target']\n security_policy_rule.redirectOptions = redirect_options\n if 'headerAction' in rule:\n header_action = messages.SecurityPolicyRuleHttpHeaderAction()\n headers_in_rule = rule['headerAction'].get('requestHeadersToAdds', [])\n headers_to_add = []\n for header_to_add in headers_in_rule:\n headers_to_add.append(\n messages.SecurityPolicyRuleHttpHeaderActionHttpHeaderOption(\n headerName=header_to_add['headerName'],\n headerValue=header_to_add['headerValue']))\n if headers_to_add:\n header_action.requestHeadersToAdds = headers_to_add\n security_policy_rule.headerAction = header_action\n if 'rateLimitOptions' in rule:\n rate_limit_options = rule['rateLimitOptions']\n security_policy_rule.rateLimitOptions = (\n messages.SecurityPolicyRuleRateLimitOptions(\n rateLimitThreshold=messages\n .SecurityPolicyRuleRateLimitOptionsThreshold(\n count=rate_limit_options['rateLimitThreshold']['count'],\n intervalSec=rate_limit_options['rateLimitThreshold']\n ['intervalSec']),\n conformAction=rate_limit_options['conformAction'],\n exceedAction=rate_limit_options['exceedAction']))\n if 'exceedActionRpcStatus' in rate_limit_options:\n exceed_action_rpc_status = (\n messages.SecurityPolicyRuleRateLimitOptionsRpcStatus()\n )\n if 'code' in rate_limit_options['exceedActionRpcStatus']:\n exceed_action_rpc_status.code = rate_limit_options[\n 'exceedActionRpcStatus']['code']\n if 'message' in rate_limit_options['exceedActionRpcStatus']:\n exceed_action_rpc_status.message = rate_limit_options[\n 'exceedActionRpcStatus']['message']\n security_policy_rule.rateLimitOptions.exceedActionRpcStatus = (\n exceed_action_rpc_status\n )\n if 'exceedRedirectOptions' in rate_limit_options:\n exceed_redirect_options = messages.SecurityPolicyRuleRedirectOptions()\n if 'type' in rate_limit_options['exceedRedirectOptions']:\n exceed_redirect_options.type = (\n messages.SecurityPolicyRuleRedirectOptions.TypeValueValuesEnum(\n rate_limit_options['exceedRedirectOptions']['type']))\n if 'target' in rate_limit_options['exceedRedirectOptions']:\n exceed_redirect_options.target = rate_limit_options[\n 'exceedRedirectOptions']['target']\n security_policy_rule.rateLimitOptions.exceedRedirectOptions = (\n exceed_redirect_options)\n if 'banThreshold' in rate_limit_options:\n security_policy_rule.rateLimitOptions.banThreshold = (\n messages.SecurityPolicyRuleRateLimitOptionsThreshold(\n count=rate_limit_options['banThreshold']['count'],\n intervalSec=rate_limit_options['banThreshold']['intervalSec']))\n if 'banDurationSec' in rate_limit_options:\n security_policy_rule.rateLimitOptions.banDurationSec = (\n rate_limit_options['banDurationSec'])\n if 'enforceOnKey' in rate_limit_options:\n security_policy_rule.rateLimitOptions.enforceOnKey = (\n messages.SecurityPolicyRuleRateLimitOptions\n .EnforceOnKeyValueValuesEnum(rate_limit_options['enforceOnKey']))\n if 'enforceOnKeyName' in rate_limit_options:\n security_policy_rule.rateLimitOptions.enforceOnKeyName = (\n rate_limit_options['enforceOnKeyName'])\n if 'preconfiguredWafConfig' in rule:\n preconfig_waf_config = messages.SecurityPolicyRulePreconfiguredWafConfig()\n for exclusion in rule['preconfiguredWafConfig'].get('exclusions', []):\n exclusion_to_add = (\n messages.SecurityPolicyRulePreconfiguredWafConfigExclusion())\n if 'targetRuleSet' in exclusion:\n exclusion_to_add.targetRuleSet = exclusion['targetRuleSet']\n for target_rule_id in exclusion.get('targetRuleIds', []):\n exclusion_to_add.targetRuleIds.append(target_rule_id)\n for request_header in exclusion.get('requestHeadersToExclude', []):\n exclusion_to_add.requestHeadersToExclude.append(\n ConvertPreconfigWafExclusionRequestField(request_header,\n messages))\n for request_cookie in exclusion.get('requestCookiesToExclude', []):\n exclusion_to_add.requestCookiesToExclude.append(\n ConvertPreconfigWafExclusionRequestField(request_cookie,\n messages))\n for request_query_param in exclusion.get('requestQueryParamsToExclude',\n []):\n exclusion_to_add.requestQueryParamsToExclude.append(\n ConvertPreconfigWafExclusionRequestField(request_query_param,\n messages))\n for request_uri in exclusion.get('requestUrisToExclude', []):\n exclusion_to_add.requestUrisToExclude.append(\n ConvertPreconfigWafExclusionRequestField(request_uri, messages))\n preconfig_waf_config.exclusions.append(exclusion_to_add)\n security_policy_rule.preconfiguredWafConfig = preconfig_waf_config\n\n security_policy.rules = rules\n\n return security_policy","def __init__(__self__,\n resource_name: str,\n args: CertificateArgs,\n opts: Optional[pulumi.ResourceOptions] = None):\n ...","def to_dict(self):\n result = {}\n\n for attr, _ in six.iteritems(self.swagger_types):\n value = getattr(self, attr)\n if isinstance(value, list):\n result[attr] = list(map(\n lambda x: x.to_dict() if hasattr(x, \"to_dict\") else x,\n value\n ))\n elif hasattr(value, \"to_dict\"):\n result[attr] = value.to_dict()\n elif isinstance(value, dict):\n result[attr] = dict(map(\n lambda item: (item[0], item[1].to_dict())\n if hasattr(item[1], \"to_dict\") else item,\n value.items()\n ))\n else:\n result[attr] = value\n if issubclass(PortainerLDAPSettings, dict):\n for key, value in self.items():\n result[key] = value\n\n return result","def settings(self) -> Optional[pulumi.Input['ConfigurationServiceSettingsArgs']]:\n return pulumi.get(self, \"settings\")","def encryption_settings_collection(self) -> Optional['outputs.EncryptionSettingsCollectionResponse']:\n return pulumi.get(self, \"encryption_settings_collection\")","def settings(self):\n from hubspot3.settings import SettingsClient\n\n return SettingsClient(**self.auth, **self.options)","def __init__(__self__,\n resource_name: str,\n args: SSLCertificateArgs,\n opts: Optional[pulumi.ResourceOptions] = None):\n ...","def settings(self) -> Dict[str, Any]:\n return {}","def __init__(self, settings):\n \n # storing otmbs settings\n self.settings = settings","def __init__( settings={} ):","def to_dict(self):\n result = {}\n\n for attr, _ in six.iteritems(self.swagger_types):\n value = getattr(self, attr)\n if isinstance(value, list):\n result[attr] = list(map(\n lambda x: x.to_dict() if hasattr(x, \"to_dict\") else x,\n value\n ))\n elif hasattr(value, \"to_dict\"):\n result[attr] = value.to_dict()\n elif isinstance(value, dict):\n result[attr] = dict(map(\n lambda item: (item[0], item[1].to_dict())\n if hasattr(item[1], \"to_dict\") else item,\n value.items()\n ))\n else:\n result[attr] = value\n if issubclass(RawDataSettingsV1, dict):\n for key, value in self.items():\n result[key] = value\n\n return result","def __init__(self):\n self.swagger_types = {\n 'source_contact': 'AddressableEntityRef',\n 'target_contact': 'AddressableEntityRef',\n 'resulting_contact': 'AddressableEntityRef'\n }\n\n self.attribute_map = {\n 'source_contact': 'sourceContact',\n 'target_contact': 'targetContact',\n 'resulting_contact': 'resultingContact'\n }\n\n self._source_contact = None\n self._target_contact = None\n self._resulting_contact = None"],"string":"[\n \"def __init__(self):\\n self.swagger_types = {\\n 'id_conta': 'int',\\n 'id_pessoa': 'int',\\n 'id_cartao': 'int',\\n 'id_bandeira': 'int',\\n 'id_tipo_cartao': 'int',\\n 'numero_cartao': 'str',\\n 'nome_plastico': 'str',\\n 'cvv2': 'str',\\n 'data_geracao': 'str',\\n 'data_validade': 'str',\\n 'cpf': 'str',\\n 'tipo_portador': 'str',\\n 'trilha1': 'str',\\n 'trilha2': 'str',\\n 'trilha_cvv1': 'str',\\n 'trilha_cvv2': 'str',\\n 'flag_virtual': 'int',\\n 'nome_bandeira': 'str',\\n 'flag_titular': 'int',\\n 'sequencial_cartao': 'int',\\n 'id_status': 'int',\\n 'descricao_status_cartao': 'str',\\n 'data_status': 'str',\\n 'id_estagio': 'int',\\n 'descricao_estagio': 'str',\\n 'data_estagio': 'str',\\n 'numero_bin': 'str',\\n 'id_produto': 'int',\\n 'descricao_produto': 'str',\\n 'id_status_conta': 'int',\\n 'descricao_status_conta': 'int',\\n 'data_embossing': 'str',\\n 'codigo_desbloqueio': 'str',\\n 'nome_pessoa': 'str',\\n 'tipo_pessoa': 'str',\\n 'data_nascimento': 'str',\\n 'id_endereco': 'int',\\n 'id_tipo_endereco': 'int',\\n 'descricao_tipo_endereco': 'str',\\n 'cep': 'str',\\n 'logradouro': 'str',\\n 'numero_endereco': 'str',\\n 'complemento_endereco': 'str',\\n 'bairro': 'str',\\n 'cidade': 'str',\\n 'uf': 'str',\\n 'pais': 'str',\\n 'senha_criptografada': 'str',\\n 'icvv': 'str',\\n 'id_status_impressao': 'int'\\n }\\n\\n self.attribute_map = {\\n 'id_conta': 'idConta',\\n 'id_pessoa': 'idPessoa',\\n 'id_cartao': 'idCartao',\\n 'id_bandeira': 'idBandeira',\\n 'id_tipo_cartao': 'idTipoCartao',\\n 'numero_cartao': 'numeroCartao',\\n 'nome_plastico': 'nomePlastico',\\n 'cvv2': 'cvv2',\\n 'data_geracao': 'dataGeracao',\\n 'data_validade': 'dataValidade',\\n 'cpf': 'cpf',\\n 'tipo_portador': 'tipoPortador',\\n 'trilha1': 'trilha1',\\n 'trilha2': 'trilha2',\\n 'trilha_cvv1': 'trilhaCVV1',\\n 'trilha_cvv2': 'trilhaCVV2',\\n 'flag_virtual': 'flagVirtual',\\n 'nome_bandeira': 'nomeBandeira',\\n 'flag_titular': 'flagTitular',\\n 'sequencial_cartao': 'sequencialCartao',\\n 'id_status': 'idStatus',\\n 'descricao_status_cartao': 'descricaoStatusCartao',\\n 'data_status': 'dataStatus',\\n 'id_estagio': 'idEstagio',\\n 'descricao_estagio': 'descricaoEstagio',\\n 'data_estagio': 'dataEstagio',\\n 'numero_bin': 'numeroBin',\\n 'id_produto': 'idProduto',\\n 'descricao_produto': 'descricaoProduto',\\n 'id_status_conta': 'idStatusConta',\\n 'descricao_status_conta': 'descricaoStatusConta',\\n 'data_embossing': 'dataEmbossing',\\n 'codigo_desbloqueio': 'codigoDesbloqueio',\\n 'nome_pessoa': 'nomePessoa',\\n 'tipo_pessoa': 'tipoPessoa',\\n 'data_nascimento': 'dataNascimento',\\n 'id_endereco': 'idEndereco',\\n 'id_tipo_endereco': 'idTipoEndereco',\\n 'descricao_tipo_endereco': 'descricaoTipoEndereco',\\n 'cep': 'cep',\\n 'logradouro': 'logradouro',\\n 'numero_endereco': 'numeroEndereco',\\n 'complemento_endereco': 'complementoEndereco',\\n 'bairro': 'bairro',\\n 'cidade': 'cidade',\\n 'uf': 'uf',\\n 'pais': 'pais',\\n 'senha_criptografada': 'senhaCriptografada',\\n 'icvv': 'icvv',\\n 'id_status_impressao': 'idStatusImpressao'\\n }\\n\\n self._id_conta = None\\n self._id_pessoa = None\\n self._id_cartao = None\\n self._id_bandeira = None\\n self._id_tipo_cartao = None\\n self._numero_cartao = None\\n self._nome_plastico = None\\n self._cvv2 = None\\n self._data_geracao = None\\n self._data_validade = None\\n self._cpf = None\\n self._tipo_portador = None\\n self._trilha1 = None\\n self._trilha2 = None\\n self._trilha_cvv1 = None\\n self._trilha_cvv2 = None\\n self._flag_virtual = None\\n self._nome_bandeira = None\\n self._flag_titular = None\\n self._sequencial_cartao = None\\n self._id_status = None\\n self._descricao_status_cartao = None\\n self._data_status = None\\n self._id_estagio = None\\n self._descricao_estagio = None\\n self._data_estagio = None\\n self._numero_bin = None\\n self._id_produto = None\\n self._descricao_produto = None\\n self._id_status_conta = None\\n self._descricao_status_conta = None\\n self._data_embossing = None\\n self._codigo_desbloqueio = None\\n self._nome_pessoa = None\\n self._tipo_pessoa = None\\n self._data_nascimento = None\\n self._id_endereco = None\\n self._id_tipo_endereco = None\\n self._descricao_tipo_endereco = None\\n self._cep = None\\n self._logradouro = None\\n self._numero_endereco = None\\n self._complemento_endereco = None\\n self._bairro = None\\n self._cidade = None\\n self._uf = None\\n self._pais = None\\n self._senha_criptografada = None\\n self._icvv = None\\n self._id_status_impressao = None\",\n \"def __init__(__self__, *,\\n type: pulumi.Input[str],\\n content: Optional[pulumi.Input[str]] = None):\\n pulumi.set(__self__, \\\"type\\\", 'ContentCertificate')\\n if content is not None:\\n pulumi.set(__self__, \\\"content\\\", content)\",\n \"def __init__(__self__, *,\\n auth_type: pulumi.Input[str],\\n certificate: pulumi.Input[str],\\n client_id: pulumi.Input[str],\\n principal_id: pulumi.Input[str]):\\n pulumi.set(__self__, \\\"auth_type\\\", 'servicePrincipalCertificate')\\n pulumi.set(__self__, \\\"certificate\\\", certificate)\\n pulumi.set(__self__, \\\"client_id\\\", client_id)\\n pulumi.set(__self__, \\\"principal_id\\\", principal_id)\",\n \"def Certificate(self) -> _n_8_t_0:\",\n \"def Certificate(self) -> _n_8_t_0:\",\n \"def __init__(__self__, *,\\n key_vault_cert_name: pulumi.Input[str],\\n type: pulumi.Input[str],\\n vault_uri: pulumi.Input[str],\\n cert_version: Optional[pulumi.Input[str]] = None,\\n exclude_private_key: Optional[pulumi.Input[bool]] = None):\\n pulumi.set(__self__, \\\"key_vault_cert_name\\\", key_vault_cert_name)\\n pulumi.set(__self__, \\\"type\\\", 'KeyVaultCertificate')\\n pulumi.set(__self__, \\\"vault_uri\\\", vault_uri)\\n if cert_version is not None:\\n pulumi.set(__self__, \\\"cert_version\\\", cert_version)\\n if exclude_private_key is None:\\n exclude_private_key = False\\n if exclude_private_key is not None:\\n pulumi.set(__self__, \\\"exclude_private_key\\\", exclude_private_key)\",\n \"def test_valid_settings() -> None:\\n SwaggerTesterSettings()\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'id': 'str',\\n 'name': 'str',\\n 'uses_git': 'bool',\\n 'git_remote_url': 'str',\\n 'git_username': 'str',\\n 'git_password': 'str',\\n 'git_username_user_attribute': 'str',\\n 'git_password_user_attribute': 'str',\\n 'git_service_name': 'str',\\n 'deploy_secret': 'str',\\n 'unset_deploy_secret': 'bool',\\n 'pull_request_mode': 'str',\\n 'validation_required': 'bool',\\n 'allow_warnings': 'bool',\\n 'is_example': 'bool',\\n 'can': 'dict(str, bool)'\\n }\\n\\n self.attribute_map = {\\n 'id': 'id',\\n 'name': 'name',\\n 'uses_git': 'uses_git',\\n 'git_remote_url': 'git_remote_url',\\n 'git_username': 'git_username',\\n 'git_password': 'git_password',\\n 'git_username_user_attribute': 'git_username_user_attribute',\\n 'git_password_user_attribute': 'git_password_user_attribute',\\n 'git_service_name': 'git_service_name',\\n 'deploy_secret': 'deploy_secret',\\n 'unset_deploy_secret': 'unset_deploy_secret',\\n 'pull_request_mode': 'pull_request_mode',\\n 'validation_required': 'validation_required',\\n 'allow_warnings': 'allow_warnings',\\n 'is_example': 'is_example',\\n 'can': 'can'\\n }\\n\\n self._id = None\\n self._name = None\\n self._uses_git = None\\n self._git_remote_url = None\\n self._git_username = None\\n self._git_password = None\\n self._git_username_user_attribute = None\\n self._git_password_user_attribute = None\\n self._git_service_name = None\\n self._deploy_secret = None\\n self._unset_deploy_secret = None\\n self._pull_request_mode = None\\n self._validation_required = None\\n self._allow_warnings = None\\n self._is_example = None\\n self._can = None\",\n \"def __init__(self, ca, cert_type):\\n self.ca = ca # required\\n self.nonce = None # optional, has default = os.urandom(32)\\n self.public_key_comment = None\\n self.serial = None # can be set, has default = 0\\n self.cert_type = None # required: User = 1, Host = 2\\n self.key_id = None # optional, default = ''\\n self.valid_principals = list() # optional, default = ''\\n self.valid_after = None # optional, default = 0\\n self.valid_before = None # optional, default = 2^64-1\\n self.critical_option_force_command = None # optional, default = ''\\n self.critical_option_source_address = None # optional, default = ''\\n self.extensions = None # optional, default = ''\\n self.reserved = '' # should always be this value\\n self.signature = None\\n self.signed_cert = None\\n self.public_key_comment = None\\n self.cert_type = cert_type\",\n \"def get_ssl_ca_settings():\\n ca_data = {}\\n https_service_endpoints = config('https-service-endpoints')\\n if (https_service_endpoints and\\n bool_from_string(https_service_endpoints)):\\n # Pass CA cert as client will need it to\\n # verify https connections\\n ca = get_ca(user=SSH_USER)\\n ca_bundle = ca.get_ca_bundle()\\n ca_data['https_keystone'] = 'True'\\n ca_data['ca_cert'] = b64encode(ca_bundle)\\n return ca_data\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'enabled': 'bool',\\n 'auto_review': 'bool',\\n 'allow_direct_trades': 'bool',\\n 'min_hours_in_future': 'int',\\n 'unequal_paid': 'str',\\n 'one_sided': 'str',\\n 'weekly_min_paid_violations': 'str',\\n 'weekly_max_paid_violations': 'str',\\n 'requires_matching_queues': 'bool',\\n 'requires_matching_languages': 'bool',\\n 'requires_matching_skills': 'bool',\\n 'requires_matching_planning_groups': 'bool',\\n 'activity_category_rules': 'list[ShiftTradeActivityRule]'\\n }\\n\\n self.attribute_map = {\\n 'enabled': 'enabled',\\n 'auto_review': 'autoReview',\\n 'allow_direct_trades': 'allowDirectTrades',\\n 'min_hours_in_future': 'minHoursInFuture',\\n 'unequal_paid': 'unequalPaid',\\n 'one_sided': 'oneSided',\\n 'weekly_min_paid_violations': 'weeklyMinPaidViolations',\\n 'weekly_max_paid_violations': 'weeklyMaxPaidViolations',\\n 'requires_matching_queues': 'requiresMatchingQueues',\\n 'requires_matching_languages': 'requiresMatchingLanguages',\\n 'requires_matching_skills': 'requiresMatchingSkills',\\n 'requires_matching_planning_groups': 'requiresMatchingPlanningGroups',\\n 'activity_category_rules': 'activityCategoryRules'\\n }\\n\\n self._enabled = None\\n self._auto_review = None\\n self._allow_direct_trades = None\\n self._min_hours_in_future = None\\n self._unequal_paid = None\\n self._one_sided = None\\n self._weekly_min_paid_violations = None\\n self._weekly_max_paid_violations = None\\n self._requires_matching_queues = None\\n self._requires_matching_languages = None\\n self._requires_matching_skills = None\\n self._requires_matching_planning_groups = None\\n self._activity_category_rules = None\",\n \"def __init__(self, **kwargs):\\n self.swagger_types = {\\n 'id': 'str',\\n 'name': 'str',\\n 'version': 'str',\\n 'tagline': 'str',\\n 'keywords': 'str',\\n 'short_description': 'str',\\n 'usage_information': 'str',\\n 'long_description': 'str',\\n 'license_model_description': 'str',\\n 'system_requirements': 'str',\\n 'time_released': 'datetime',\\n 'release_notes': 'str',\\n 'categories': 'list[str]',\\n 'publisher': 'Publisher',\\n 'languages': 'list[Item]',\\n 'screenshots': 'list[Screenshot]',\\n 'videos': 'list[NamedLink]',\\n 'support_contacts': 'list[SupportContact]',\\n 'support_links': 'list[NamedLink]',\\n 'documentation_links': 'list[DocumentationLink]',\\n 'icon': 'UploadData',\\n 'banner': 'UploadData',\\n 'regions': 'list[Region]',\\n 'package_type': 'str',\\n 'default_package_version': 'str',\\n 'links': 'list[Link]',\\n 'is_featured': 'bool'\\n }\\n\\n self.attribute_map = {\\n 'id': 'id',\\n 'name': 'name',\\n 'version': 'version',\\n 'tagline': 'tagline',\\n 'keywords': 'keywords',\\n 'short_description': 'shortDescription',\\n 'usage_information': 'usageInformation',\\n 'long_description': 'longDescription',\\n 'license_model_description': 'licenseModelDescription',\\n 'system_requirements': 'systemRequirements',\\n 'time_released': 'timeReleased',\\n 'release_notes': 'releaseNotes',\\n 'categories': 'categories',\\n 'publisher': 'publisher',\\n 'languages': 'languages',\\n 'screenshots': 'screenshots',\\n 'videos': 'videos',\\n 'support_contacts': 'supportContacts',\\n 'support_links': 'supportLinks',\\n 'documentation_links': 'documentationLinks',\\n 'icon': 'icon',\\n 'banner': 'banner',\\n 'regions': 'regions',\\n 'package_type': 'packageType',\\n 'default_package_version': 'defaultPackageVersion',\\n 'links': 'links',\\n 'is_featured': 'isFeatured'\\n }\\n\\n self._id = None\\n self._name = None\\n self._version = None\\n self._tagline = None\\n self._keywords = None\\n self._short_description = None\\n self._usage_information = None\\n self._long_description = None\\n self._license_model_description = None\\n self._system_requirements = None\\n self._time_released = None\\n self._release_notes = None\\n self._categories = None\\n self._publisher = None\\n self._languages = None\\n self._screenshots = None\\n self._videos = None\\n self._support_contacts = None\\n self._support_links = None\\n self._documentation_links = None\\n self._icon = None\\n self._banner = None\\n self._regions = None\\n self._package_type = None\\n self._default_package_version = None\\n self._links = None\\n self._is_featured = None\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'access_zone': 'str',\\n 'aggregation_mode': 'str',\\n 'alloc_method': 'str',\\n 'description': 'str',\\n 'ifaces': 'list[SubnetsSubnetPoolIface]',\\n 'name': 'str',\\n 'ranges': 'list[SubnetsSubnetPoolRange]',\\n 'rebalance_policy': 'str',\\n 'sc_auto_unsuspend_delay': 'int',\\n 'sc_connect_policy': 'str',\\n 'sc_dns_zone': 'str',\\n 'sc_dns_zone_aliases': 'list[str]',\\n 'sc_failover_policy': 'str',\\n 'sc_subnet': 'str',\\n 'sc_ttl': 'int',\\n 'static_routes': 'list[SubnetsSubnetPoolStaticRoute]'\\n }\\n\\n self.attribute_map = {\\n 'access_zone': 'access_zone',\\n 'aggregation_mode': 'aggregation_mode',\\n 'alloc_method': 'alloc_method',\\n 'description': 'description',\\n 'ifaces': 'ifaces',\\n 'name': 'name',\\n 'ranges': 'ranges',\\n 'rebalance_policy': 'rebalance_policy',\\n 'sc_auto_unsuspend_delay': 'sc_auto_unsuspend_delay',\\n 'sc_connect_policy': 'sc_connect_policy',\\n 'sc_dns_zone': 'sc_dns_zone',\\n 'sc_dns_zone_aliases': 'sc_dns_zone_aliases',\\n 'sc_failover_policy': 'sc_failover_policy',\\n 'sc_subnet': 'sc_subnet',\\n 'sc_ttl': 'sc_ttl',\\n 'static_routes': 'static_routes'\\n }\\n\\n self._access_zone = None\\n self._aggregation_mode = None\\n self._alloc_method = None\\n self._description = None\\n self._ifaces = None\\n self._name = None\\n self._ranges = None\\n self._rebalance_policy = None\\n self._sc_auto_unsuspend_delay = None\\n self._sc_connect_policy = None\\n self._sc_dns_zone = None\\n self._sc_dns_zone_aliases = None\\n self._sc_failover_policy = None\\n self._sc_subnet = None\\n self._sc_ttl = None\\n self._static_routes = None\",\n \"def create_settings():\\n\\n settings = {}\\n\\n settings['induction'] = {'type': 'DT'}\\n\\n settings['selection'] = {'type': 'Base',\\n 'its': 1,\\n 'param': 1}\\n\\n settings['prediction'] = {'type': 'MI',\\n 'its': 0.1,\\n 'param': 0.95}\\n\\n settings['queries'] = {}\\n\\n settings['metadata'] = {}\\n\\n settings['model_data'] = {}\\n\\n return settings\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'id_conta': 'int',\\n 'id_produto': 'int',\\n 'id_pessoa': 'int',\\n 'id_parentesco': 'int',\\n 'tipo_portador': 'str',\\n 'nome_impresso': 'str',\\n 'id_tipo_cartao': 'int',\\n 'flag_ativo': 'int',\\n 'data_cadastro_portador': 'str',\\n 'data_cancelamento_portador': 'str'\\n }\\n\\n self.attribute_map = {\\n 'id_conta': 'idConta',\\n 'id_produto': 'idProduto',\\n 'id_pessoa': 'idPessoa',\\n 'id_parentesco': 'idParentesco',\\n 'tipo_portador': 'tipoPortador',\\n 'nome_impresso': 'nomeImpresso',\\n 'id_tipo_cartao': 'idTipoCartao',\\n 'flag_ativo': 'flagAtivo',\\n 'data_cadastro_portador': 'dataCadastroPortador',\\n 'data_cancelamento_portador': 'dataCancelamentoPortador'\\n }\\n\\n self._id_conta = None\\n self._id_produto = None\\n self._id_pessoa = None\\n self._id_parentesco = None\\n self._tipo_portador = None\\n self._nome_impresso = None\\n self._id_tipo_cartao = None\\n self._flag_ativo = None\\n self._data_cadastro_portador = None\\n self._data_cancelamento_portador = None\",\n \"def config_schema():\\n # pylint: disable=no-value-for-parameter\\n return Schema(\\n {\\n Optional('other_settings', default={}): {\\n Optional('master_only', default=False): Boolean(),\\n Optional('skip_version_test', default=False): Boolean(),\\n Optional('username', default=None): Any(None, *string_types),\\n Optional('password', default=None): Any(None, *string_types),\\n Optional('api_key', default={}): {\\n Optional('id'): Any(None, *string_types),\\n Optional('api_key'): Any(None, *string_types),\\n Optional('token'): Any(None, *string_types),\\n }\\n },\\n Optional('client', default={}): {\\n Optional('hosts', default=None): Any(None, list, *string_types),\\n Optional('cloud_id', default=None): Any(None, *string_types),\\n Optional('api_key'): Any(None, tuple),\\n Optional('basic_auth'): Any(None, tuple),\\n Optional('bearer_auth'): Any(None, *string_types),\\n Optional('opaque_id'): Any(None, *string_types),\\n Optional('headers'): Any(None, dict),\\n Optional('connections_per_node'): Any(None, All(Coerce(int), Range(min=1, max=100))),\\n Optional('http_compress'): Boolean(),\\n Optional('verify_certs'): Boolean(),\\n Optional('ca_certs'): Any(None, *string_types),\\n Optional('client_cert'): Any(None, *string_types),\\n Optional('client_key'): Any(None, *string_types),\\n\\n #: Hostname or IP address to verify on the node's certificate.\\n #: This is useful if the certificate contains a different value\\n #: than the one supplied in ``host``. An example of this situation\\n #: is connecting to an IP address instead of a hostname.\\n #: Set to ``False`` to disable certificate hostname verification.\\n Optional('ssl_assert_hostname'): Any(None, *string_types),\\n\\n #: SHA-256 fingerprint of the node's certificate. If this value is\\n #: given then root-of-trust verification isn't done and only the\\n #: node's certificate fingerprint is verified.\\n #:\\n #: On CPython 3.10+ this also verifies if any certificate in the\\n #: chain including the Root CA matches this fingerprint. However\\n #: because this requires using private APIs support for this is\\n #: **experimental**.\\n Optional('ssl_assert_fingerprint'): Any(None, *string_types),\\n\\n Optional('ssl_version'): Any(None, *string_types), # Minimum acceptable TLS/SSL version\\n\\n #: Pre-configured :class:`ssl.SSLContext` OBJECT. If this value\\n #: is given then no other TLS options (besides ``ssl_assert_fingerprint``)\\n #: can be set on the :class:`elastic_transport.NodeConfig`.\\n ### Keeping this here in case someone APIs it, but otherwise it's not likely to be used.\\n Optional('ssl_context'): Any(None, *string_types),\\n\\n Optional('ssl_show_warn'): Boolean(),\\n Optional('transport_class'): Any(None, *string_types),\\n Optional('request_timeout'): Any(None, All(Coerce(float), Range(min=0.1, max=86400.0))),\\n\\n # node_class: Union[str, Type[BaseNode]] = Urllib3HttpNode,\\n Optional('node_class'): Any(None, *string_types),\\n\\n # node_pool_class: Type[NodePool] = NodePool,\\n Optional('node_pool_class'): Any(None, *string_types),\\n\\n Optional('randomize_nodes_in_pool'): Boolean(),\\n\\n # node_selector_class: Optional[Union[str, Type[NodeSelector]]] = None,\\n Optional('node_selector_class'): Any(None, *string_types),\\n\\n Optional('dead_node_backoff_factor'): Any(None, float),\\n Optional('max_dead_node_backoff'): Any(None, float),\\n\\n # One of:\\n # \\\"Serializer\\\"\\n # \\\"JsonSerializer\\\"\\n # \\\"TextSerializer\\\"\\n # \\\"NdjsonSerializer\\\"\\n # \\\"CompatibilityModeJsonSerializer\\\"\\n # \\\"CompatibilityModeNdjsonSerializer\\\"\\n # \\\"MapboxVectorTileSerializer\\\"\\n Optional('serializer'): Any(None, *string_types), # ???\\n\\n # :arg serializers: optional dict of serializer instances that will be\\n # used for deserializing data coming from the server. (key is the mimetype)\\n # e.g.: {'mimetype':'serializer'}\\n # \\\"Serializer\\\"\\n # \\\"JsonSerializer\\\"\\n # \\\"TextSerializer\\\"\\n # \\\"NdjsonSerializer\\\"\\n # \\\"CompatibilityModeJsonSerializer\\\"\\n # \\\"CompatibilityModeNdjsonSerializer\\\"\\n # \\\"MapboxVectorTileSerializer\\\"\\n Optional('serializers'): Any(None, dict),\\n\\n Optional('default_mimetype'): Any(None, *string_types),\\n Optional('max_retries'): Any(None, All(Coerce(int), Range(min=1, max=100))),\\n\\n # retry_on_status: Collection[int] = (429, 502, 503, 504),\\n Optional('retry_on_status'): Any(None, tuple),\\n\\n Optional('retry_on_timeout'): Boolean(),\\n Optional('sniff_on_start'): Boolean(),\\n Optional('sniff_before_requests'): Boolean(),\\n Optional('sniff_on_node_failure'): Boolean(),\\n Optional('sniff_timeout'): Any(None, All(Coerce(float), Range(min=0.1, max=100.0))),\\n Optional('min_delay_between_sniffing'): Any(None, All(Coerce(float), Range(min=1, max=100.0))),\\n\\n # Optional[\\n # Callable[\\n # [\\\"Transport\\\", \\\"SniffOptions\\\"],\\n # Union[List[NodeConfig], List[NodeConfig]],\\n # ]\\n # ] = None,\\n Optional('sniffed_node_callback'): Any(None, *string_types),\\n\\n Optional('meta_header'): Boolean(),\\n\\n # Cannot specify both 'request_timeout' and 'timeout'\\n # Optional('timeout', default=10.0): All(Coerce(float), Range(min=1, max=120)),\\n\\n # Cannot specify both 'randomize_hosts' and 'randomize_nodes_in_pool'\\n # Optional('randomize_hosts', default=True): Boolean(),\\n\\n Optional('host_info_callback'): Any(None, *string_types), # ??? needs the name of a callback function\\n\\n # Cannot specify both 'sniffer_timeout' and 'min_delay_between_sniffing'\\n # Optional('sniffer_timeout', default=0.5): All(Coerce(float), Range(min=0.1, max=10.0)),\\n\\n # Cannot specify both 'sniff_on_connection_fail' and 'sniff_on_node_failure'\\n # Optional('sniff_on_connection_fail', default=False): Boolean(),\\n\\n # Optional('http_auth'): Any(None, *string_types), # ??? Favor basic_auth instead.w\\n Optional('_transport'): Any(None, *string_types) # ???\\n }\\n }\\n )\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'owner_id': 'str',\\n 'created_at': 'datetime',\\n 'identifier': 'str',\\n 'identifier_type': 'str',\\n 'default_language': 'str',\\n 'optional_identifier': 'str',\\n 'id': 'str',\\n 'v': 'float',\\n 'id': 'str',\\n 'case_records': 'list[str]'\\n }\\n\\n self.attribute_map = {\\n 'owner_id': '_ownerId',\\n 'created_at': '_createdAt',\\n 'identifier': 'identifier',\\n 'identifier_type': 'identifierType',\\n 'default_language': 'defaultLanguage',\\n 'optional_identifier': 'optionalIdentifier',\\n 'id': '_id',\\n 'v': '__v',\\n 'case_records': 'caseRecords'\\n }\\n\\n self._owner_id = None\\n self._created_at = None\\n self._identifier = None\\n self._identifier_type = None\\n self._default_language = None\\n self._optional_identifier = None\\n self._id = None\\n self._v = None\\n self._id = None\\n self._case_records = None\",\n \"def __init__(self): # noqa: E501\\n self.openapi_types = {\\n }\\n\\n self.attribute_map = {\\n }\",\n \"async def get_trace_settings(\\n self,\\n model_name: str = ...,\\n headers: dict[str, t.Any] = ...,\\n as_json: t.Literal[False] = ...,\\n ) -> service_pb2.TraceSettingResponse:\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'id': 'str',\\n 'domain': 'str',\\n 'custom_domain': 'str',\\n 'customer_email': 'str',\\n 'customer_name': 'str',\\n 'company': 'str',\\n 'date_created': 'datetime',\\n 'date_validity': 'datetime',\\n 'status': 'str',\\n 'account_id': 'str',\\n 'cluster_id': 'str',\\n 'task_id': 'str',\\n 'version': 'str',\\n 'is_latest': 'bool',\\n 'product_id': 'str',\\n 'variation_id': 'str'\\n }\\n\\n self.attribute_map = {\\n 'id': 'id',\\n 'domain': 'domain',\\n 'custom_domain': 'custom_domain',\\n 'customer_email': 'customer_email',\\n 'customer_name': 'customer_name',\\n 'company': 'company',\\n 'date_created': 'date_created',\\n 'date_validity': 'date_validity',\\n 'status': 'status',\\n 'account_id': 'account_id',\\n 'cluster_id': 'cluster_id',\\n 'task_id': 'task_id',\\n 'version': 'version',\\n 'is_latest': 'is_latest',\\n 'product_id': 'product_id',\\n 'variation_id': 'variation_id'\\n }\\n\\n self._id = None\\n self._domain = None\\n self._custom_domain = None\\n self._customer_email = None\\n self._customer_name = None\\n self._company = None\\n self._date_created = None\\n self._date_validity = None\\n self._status = None\\n self._account_id = None\\n self._cluster_id = None\\n self._task_id = None\\n self._version = None\\n self._is_latest = None\\n self._product_id = None\\n self._variation_id = None\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'id': 'str',\\n 'name': 'str',\\n 'date_created': 'datetime',\\n 'date_modified': 'datetime',\\n 'version': 'int',\\n 'division': 'DomainEntityRef',\\n 'campaign_status': 'str',\\n 'callable_time_set': 'DomainEntityRef',\\n 'contact_list': 'DomainEntityRef',\\n 'dnc_lists': 'list[DomainEntityRef]',\\n 'always_running': 'bool',\\n 'contact_sorts': 'list[ContactSort]',\\n 'messages_per_minute': 'int',\\n 'errors': 'list[RestErrorDetail]',\\n 'sms_config': 'SmsConfig',\\n 'self_uri': 'str'\\n }\\n\\n self.attribute_map = {\\n 'id': 'id',\\n 'name': 'name',\\n 'date_created': 'dateCreated',\\n 'date_modified': 'dateModified',\\n 'version': 'version',\\n 'division': 'division',\\n 'campaign_status': 'campaignStatus',\\n 'callable_time_set': 'callableTimeSet',\\n 'contact_list': 'contactList',\\n 'dnc_lists': 'dncLists',\\n 'always_running': 'alwaysRunning',\\n 'contact_sorts': 'contactSorts',\\n 'messages_per_minute': 'messagesPerMinute',\\n 'errors': 'errors',\\n 'sms_config': 'smsConfig',\\n 'self_uri': 'selfUri'\\n }\\n\\n self._id = None\\n self._name = None\\n self._date_created = None\\n self._date_modified = None\\n self._version = None\\n self._division = None\\n self._campaign_status = None\\n self._callable_time_set = None\\n self._contact_list = None\\n self._dnc_lists = None\\n self._always_running = None\\n self._contact_sorts = None\\n self._messages_per_minute = None\\n self._errors = None\\n self._sms_config = None\\n self._self_uri = None\",\n \"def settings_set_callsign(self):\\n\\n # The command parameters\\n command_parameters = [\\n {\\n \\\"type\\\": \\\"string\\\",\\n \\\"minlength\\\": 1,\\n \\\"maxlength\\\": 1,\\n \\\"required\\\": True,\\n \\\"title\\\": \\\"callsign\\\",\\n \\\"description\\\": \\\"The APRS callsign to be tracked.\\\"\\n }\\n ]\\n\\n return build_metadata_dict(command_parameters, 'set_callsign', self.name, requires_active_session = True,\\n use_as_initial_value = True)\",\n \"def settings(self) -> SchemaActionModel:\\n from whyqd.models import SchemaActionModel\\n\\n action_settings = {\\n \\\"name\\\": self.name,\\n \\\"title\\\": self.title,\\n \\\"description\\\": self.description,\\n \\\"structure\\\": self.structure,\\n }\\n if self.modifiers:\\n action_settings[\\\"modifiers\\\"] = self.modifiers\\n return SchemaActionModel(**action_settings)\",\n \"def settings(self):\\r\\n return SettingResource(self)\",\n \"def cont_settings_(request):\\n \\n return {\\\"settings\\\": settings}\",\n \"def save(self):\\n self.client._perform_empty(\\n \\\"PUT\\\", \\\"/projects/%s/apiservices/%s/settings\\\" % (self.project_key, self.service_id),\\n body = self.settings)\",\n \"def get_zcs_settings(session, return_type=None, **kwargs):\\n path = '/api/settings/container_service.json'\\n\\n return session.get_api(path=path, return_type=return_type, **kwargs)\",\n \"def get_conversion_options_schema(self) -> dict:\\n conversion_options_schema = get_base_schema(\\n root=True,\\n id_=\\\"conversion_options.schema.json\\\",\\n title=\\\"Conversion options schema\\\",\\n description=\\\"Schema for the conversion options\\\",\\n version=\\\"0.1.0\\\",\\n )\\n for interface_name, data_interface in self.data_interface_objects.items():\\n conversion_options_schema[\\\"properties\\\"].update(\\n {interface_name: unroot_schema(data_interface.get_conversion_options_schema())}\\n )\\n return conversion_options_schema\",\n \"def get_conversion_options_schema(self) -> dict:\\n conversion_options_schema = get_base_schema(\\n root=True,\\n id_=\\\"conversion_options.schema.json\\\",\\n title=\\\"Conversion options schema\\\",\\n description=\\\"Schema for the conversion options\\\",\\n version=\\\"0.1.0\\\",\\n )\\n for interface_name, data_interface in self.data_interface_objects.items():\\n conversion_options_schema[\\\"properties\\\"].update(\\n {interface_name: unroot_schema(data_interface.get_conversion_options_schema())}\\n )\\n return conversion_options_schema\",\n \"def settings_config(session, return_type=None, **kwargs):\\n path = '/api/return_type.json'\\n return session.get_api(path=path, return_type=return_type, **kwargs)\",\n \"def settings(self):\\n if self._settings is not None:\\n return self._settings\\n\\n settings = self.binaries['KeeAgent.settings'].content\\n self._settings = objectify.fromstring(settings)\\n return self._settings\",\n \"async def settings(self, ctx: BBContext):\\n pass\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'autocreate': 'bool',\\n 'autodelete': 'bool',\\n 'global_visible_accessible': 'bool',\\n 'local_root_accessible': 'bool',\\n 'local_root_visible': 'bool',\\n 'local_subdir_accessible': 'bool',\\n 'nfs_root_accessible': 'bool',\\n 'nfs_root_visible': 'bool',\\n 'nfs_subdir_accessible': 'bool',\\n 'reserve': 'float',\\n 'service': 'bool',\\n 'smb_root_accessible': 'bool',\\n 'smb_root_visible': 'bool',\\n 'smb_subdir_accessible': 'bool'\\n }\\n\\n self.attribute_map = {\\n 'autocreate': 'autocreate',\\n 'autodelete': 'autodelete',\\n 'global_visible_accessible': 'global_visible_accessible',\\n 'local_root_accessible': 'local_root_accessible',\\n 'local_root_visible': 'local_root_visible',\\n 'local_subdir_accessible': 'local_subdir_accessible',\\n 'nfs_root_accessible': 'nfs_root_accessible',\\n 'nfs_root_visible': 'nfs_root_visible',\\n 'nfs_subdir_accessible': 'nfs_subdir_accessible',\\n 'reserve': 'reserve',\\n 'service': 'service',\\n 'smb_root_accessible': 'smb_root_accessible',\\n 'smb_root_visible': 'smb_root_visible',\\n 'smb_subdir_accessible': 'smb_subdir_accessible'\\n }\\n\\n self._autocreate = None\\n self._autodelete = None\\n self._global_visible_accessible = None\\n self._local_root_accessible = None\\n self._local_root_visible = None\\n self._local_subdir_accessible = None\\n self._nfs_root_accessible = None\\n self._nfs_root_visible = None\\n self._nfs_subdir_accessible = None\\n self._reserve = None\\n self._service = None\\n self._smb_root_accessible = None\\n self._smb_root_visible = None\\n self._smb_subdir_accessible = None\",\n \"def test_create_hyperflex_proxy_setting_policy(self):\\n pass\",\n \"def to_dict(self):\\n result = {}\\n\\n for attr, _ in six.iteritems(self.swagger_types):\\n value = getattr(self, attr)\\n if isinstance(value, list):\\n result[attr] = list(map(\\n lambda x: x.to_dict() if hasattr(x, \\\"to_dict\\\") else x,\\n value\\n ))\\n elif hasattr(value, \\\"to_dict\\\"):\\n result[attr] = value.to_dict()\\n elif isinstance(value, dict):\\n result[attr] = dict(map(\\n lambda item: (item[0], item[1].to_dict())\\n if hasattr(item[1], \\\"to_dict\\\") else item,\\n value.items()\\n ))\\n else:\\n result[attr] = value\\n if issubclass(CertificatePayload, dict):\\n for key, value in self.items():\\n result[key] = value\\n\\n return result\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'app_id': 'int',\\n 'app_sw_rev': 'str',\\n 'avg_hops': 'float',\\n 'avg_latency': 'int',\\n 'charge': 'int',\\n 'estimated_latency_to_mote': 'int',\\n 'hw_model': 'int',\\n 'hw_rev': 'int',\\n 'id': 'int',\\n 'join_sys_time': 'datetime',\\n 'last_voltage': 'int',\\n 'lost_packet_count': 'int',\\n 'mac_address': 'str',\\n 'max_current': 'int',\\n 'max_num_links': 'int',\\n 'max_num_neighbors': 'int',\\n 'need_neighbor': 'bool',\\n 'num_good_neighbors': 'int',\\n 'num_joins': 'int',\\n 'num_links': 'int',\\n 'num_neighbors': 'int',\\n 'num_parents': 'int',\\n 'power_cost_rx_link': 'int',\\n 'power_cost_tx_link': 'int',\\n 'reliability': 'float',\\n 'rx_packet_count': 'int',\\n 'stack_sw_rev': 'str',\\n 'state': 'str',\\n 'state_reason': 'str',\\n 'state_sys_time': 'datetime',\\n 'used_current': 'int'\\n }\\n\\n self.attribute_map = {\\n 'app_id': 'appId',\\n 'app_sw_rev': 'appSwRev',\\n 'avg_hops': 'avgHops',\\n 'avg_latency': 'avgLatency',\\n 'charge': 'charge',\\n 'estimated_latency_to_mote': 'estimatedLatencyToMote',\\n 'hw_model': 'hwModel',\\n 'hw_rev': 'hwRev',\\n 'id': 'id',\\n 'join_sys_time': 'joinSysTime',\\n 'last_voltage': 'lastVoltage',\\n 'lost_packet_count': 'lostPacketCount',\\n 'mac_address': 'macAddress',\\n 'max_current': 'maxCurrent',\\n 'max_num_links': 'maxNumLinks',\\n 'max_num_neighbors': 'maxNumNeighbors',\\n 'need_neighbor': 'needNeighbor',\\n 'num_good_neighbors': 'numGoodNeighbors',\\n 'num_joins': 'numJoins',\\n 'num_links': 'numLinks',\\n 'num_neighbors': 'numNeighbors',\\n 'num_parents': 'numParents',\\n 'power_cost_rx_link': 'powerCostRxLink',\\n 'power_cost_tx_link': 'powerCostTxLink',\\n 'reliability': 'reliability',\\n 'rx_packet_count': 'rxPacketCount',\\n 'stack_sw_rev': 'stackSwRev',\\n 'state': 'state',\\n 'state_reason': 'stateReason',\\n 'state_sys_time': 'stateSysTime',\\n 'used_current': 'usedCurrent'\\n }\\n\\n self._app_id = None\\n self._app_sw_rev = None\\n self._avg_hops = None\\n self._avg_latency = None\\n self._charge = None\\n self._estimated_latency_to_mote = None\\n self._hw_model = None\\n self._hw_rev = None\\n self._id = None\\n self._join_sys_time = None\\n self._last_voltage = None\\n self._lost_packet_count = None\\n self._mac_address = None\\n self._max_current = None\\n self._max_num_links = None\\n self._max_num_neighbors = None\\n self._need_neighbor = None\\n self._num_good_neighbors = None\\n self._num_joins = None\\n self._num_links = None\\n self._num_neighbors = None\\n self._num_parents = None\\n self._power_cost_rx_link = None\\n self._power_cost_tx_link = None\\n self._reliability = None\\n self._rx_packet_count = None\\n self._stack_sw_rev = None\\n self._state = None\\n self._state_reason = None\\n self._state_sys_time = None\\n self._used_current = None\",\n \"def set_security(self, secobj):\\n with SecurityDocument(self.cloudant_database) as sec_doc:\\n # context manager saves\\n for key in sec_doc:\\n del sec_doc[key]\\n for k, v in secobj.items():\\n sec_doc[k] = v\\n return self.get_security()\",\n \"def __init__(__self__, *,\\n enable_certificates: Optional[pulumi.Input[bool]] = None):\\n if enable_certificates is not None:\\n pulumi.set(__self__, \\\"enable_certificates\\\", enable_certificates)\",\n \"def __init__(__self__, *,\\n enable_certificates: Optional[pulumi.Input[bool]] = None):\\n if enable_certificates is not None:\\n pulumi.set(__self__, \\\"enable_certificates\\\", enable_certificates)\",\n \"def _generate_implicit_api_resource(self):\\n return ImplicitHttpApiResource().to_dict()\",\n \"def generate_ipsec_conf(strongswan_obj, **kwargs):\\r\\n return strongswan_obj.create_ipsec_conf(**kwargs)\",\n \"def get_certificate_issuance_config_output(certificate_issuance_config_id: Optional[pulumi.Input[str]] = None,\\n location: Optional[pulumi.Input[str]] = None,\\n project: Optional[pulumi.Input[Optional[str]]] = None,\\n opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetCertificateIssuanceConfigResult]:\\n ...\",\n \"def __eq__(self, other):\\n if not isinstance(other, TypesConsoleCertificateSettings):\\n return False\\n\\n return self.to_dict() == other.to_dict()\",\n \"def _get_kind(cls):\\n return 'CredentialsModel'\",\n \"def _get_config_data(self, cr, uid):\\n\\n model_conf = self.pool.get('customer.support.settings')\\n args = [('selected', '=', True)] \\n ids = model_conf.search(cr, uid, args)\\n config = model_conf.browse(cr, uid, ids[0])\\n\\n return {\\n 'tor_api_key': config.tor_api_key,\\n 'tor_domain': config.tor_domain,\\n 'company': config.company\\n }\",\n \"def cdap_settings(configs_dir):\\n return config.read_model_settings(configs_dir, 'cdap.yaml')\",\n \"def edit_certificate(self, certificate):\\r\\n return self.ssl.editObject(certificate, id=certificate['id'])\",\n \"def default_configs(cls):\\n config = super().default_configs()\\n config.update(\\n {\\n \\\"entry_type\\\": \\\"ft.onto.base_ontology.Document\\\",\\n \\\"model_name\\\": \\\"ktrapeznikov/biobert_v1.1_pubmed_squad_v2\\\",\\n \\\"question\\\": \\\"Where do I live\\\",\\n \\\"max_answer_len\\\": 15,\\n \\\"cuda_devices\\\": -1,\\n \\\"handle_impossible_answer\\\": False,\\n }\\n )\\n return config\",\n \"def test_user_settings_serialization(self):\\n\\n # Construct a json representation of a UserSettings model\\n user_settings_model_json = {}\\n user_settings_model_json['language'] = 'testString'\\n user_settings_model_json['notification_language'] = 'testString'\\n user_settings_model_json['allowed_ip_addresses'] = '32.96.110.50,172.16.254.1'\\n user_settings_model_json['self_manage'] = True\\n\\n # Construct a model instance of UserSettings by calling from_dict on the json representation\\n user_settings_model = UserSettings.from_dict(user_settings_model_json)\\n assert user_settings_model != False\\n\\n # Construct a model instance of UserSettings by calling from_dict on the json representation\\n user_settings_model_dict = UserSettings.from_dict(user_settings_model_json).__dict__\\n user_settings_model2 = UserSettings(**user_settings_model_dict)\\n\\n # Verify the model instances are equivalent\\n assert user_settings_model == user_settings_model2\\n\\n # Convert model instance back to dict and verify no loss of data\\n user_settings_model_json2 = user_settings_model.to_dict()\\n assert user_settings_model_json2 == user_settings_model_json\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'id': 'str',\\n 'ticket_id': 'str',\\n 'type': 'str',\\n 'from_number': 'str',\\n 'from_name': 'str',\\n 'to_number': 'str',\\n 'to_name': 'str',\\n 'via_number': 'str',\\n 'date_created': 'datetime',\\n 'date_answered': 'datetime',\\n 'date_finished': 'datetime'\\n }\\n\\n self.attribute_map = {\\n 'id': 'id',\\n 'ticket_id': 'ticketId',\\n 'type': 'type',\\n 'from_number': 'fromNumber',\\n 'from_name': 'fromName',\\n 'to_number': 'toNumber',\\n 'to_name': 'toName',\\n 'via_number': 'viaNumber',\\n 'date_created': 'dateCreated',\\n 'date_answered': 'dateAnswered',\\n 'date_finished': 'dateFinished'\\n }\\n\\n self._id = None\\n self._ticket_id = None\\n self._type = None\\n self._from_number = None\\n self._from_name = None\\n self._to_number = None\\n self._to_name = None\\n self._via_number = None\\n self._date_created = None\\n self._date_answered = None\\n self._date_finished = None\",\n \"def to_dict(self):\\n result = {}\\n\\n for attr, _ in six.iteritems(self.swagger_types):\\n value = getattr(self, attr)\\n if isinstance(value, list):\\n result[attr] = list(map(\\n lambda x: x.to_dict() if hasattr(x, \\\"to_dict\\\") else x,\\n value\\n ))\\n elif hasattr(value, \\\"to_dict\\\"):\\n result[attr] = value.to_dict()\\n elif isinstance(value, dict):\\n result[attr] = dict(map(\\n lambda item: (item[0], item[1].to_dict())\\n if hasattr(item[1], \\\"to_dict\\\") else item,\\n value.items()\\n ))\\n else:\\n result[attr] = value\\n if issubclass(AccessPolicyLoggingSettingModel, dict):\\n for key, value in self.items():\\n result[key] = value\\n\\n return result\",\n \"def openapi_types():\\n lazy_import()\\n return {\\n 'geolocation_settings': (OtoroshiModelsGeolocationSettings,), # noqa: E501\\n 'alerts_emails': ([str],), # noqa: E501\\n 'throttling_quota': (int,), # noqa: E501\\n 'max_webhook_size': (int,), # noqa: E501\\n 'max_concurrent_requests': (int,), # noqa: E501\\n 'clever_settings': (dict,), # noqa: E501\\n 'endless_ip_addresses': ([str],), # noqa: E501\\n 'plugins': (OtoroshiScriptPluginsPlugins,), # noqa: E501\\n 'kafka_config': (dict,), # noqa: E501\\n 'max_logs_size': (int,), # noqa: E501\\n 'proxies': (OtoroshiModelsProxies,), # noqa: E501\\n 'enable_embedded_metrics': (bool,), # noqa: E501\\n 'elastic_reads_config': (dict,), # noqa: E501\\n 'tags': ([str],), # noqa: E501\\n 'limit_concurrent_requests': (bool,), # noqa: E501\\n 'use_akka_http_client': (bool,), # noqa: E501\\n 'elastic_writes_configs': ([OtoroshiModelsElasticAnalyticsConfig],), # noqa: E501\\n 'log_analytics_on_server': (bool,), # noqa: E501\\n 'metadata': ({str: (str,)},), # noqa: E501\\n 'api_read_only': (bool,), # noqa: E501\\n 'back_office_auth_ref': (dict,), # noqa: E501\\n 'stream_entity_only': (bool,), # noqa: E501\\n 'otoroshi_id': (str,), # noqa: E501\\n 'mailer_settings': (dict,), # noqa: E501\\n 'lines': ([str],), # noqa: E501\\n 'middle_fingers': (bool,), # noqa: E501\\n 'analytics_webhooks': ([OtoroshiModelsWebhook],), # noqa: E501\\n 'auto_cert': (OtoroshiModelsAutoCert,), # noqa: E501\\n 'maintenance_mode': (bool,), # noqa: E501\\n 'lets_encrypt_settings': (OtoroshiUtilsLetsencryptLetsEncryptSettings,), # noqa: E501\\n 'snow_monkey_config': (OtoroshiModelsSnowMonkeyConfig,), # noqa: E501\\n 'scripts': (OtoroshiModelsGlobalScripts,), # noqa: E501\\n 'per_ip_throttling_quota': (int,), # noqa: E501\\n 'use_circuit_breakers': (bool,), # noqa: E501\\n 'max_http10_response_size': (int,), # noqa: E501\\n 'tls_settings': (OtoroshiModelsTlsSettings,), # noqa: E501\\n 'statsd_config': (dict,), # noqa: E501\\n 'auto_link_to_default_group': (bool,), # noqa: E501\\n 'alerts_webhooks': ([OtoroshiModelsWebhook],), # noqa: E501\\n 'ip_filtering': (OtoroshiModelsIpFiltering,), # noqa: E501\\n 'u2f_login_only': (bool,), # noqa: E501\\n 'user_agent_settings': (OtoroshiModelsUserAgentSettings,), # noqa: E501\\n }\",\n \"def get_settings(self):\\n settings = self.client._perform_json(\\n \\\"GET\\\", \\\"/projects/%s/apiservices/%s/settings\\\" % (self.project_key, self.service_id))\\n\\n return DSSAPIServiceSettings(self.client, self.project_key, self.service_id, settings)\",\n \"def get_spec(self):\\n from schematics.types import ModelType\\n spec = {\\n 'id': self.name,\\n 'description': self.description,\\n 'addressable': self.array,\\n 'required': self.required,\\n }\\n if self.type.has_schema:\\n spec['schema'] = self.type.get_spec()\\n else:\\n spec.update(self.type.get_spec())\\n\\n return spec\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'is_waiting': 'bool',\\n 'is_active': 'bool',\\n 'is_acd': 'bool',\\n 'is_preferred': 'bool',\\n 'is_screenshare': 'bool',\\n 'is_cobrowse': 'bool',\\n 'is_voicemail': 'bool',\\n 'is_flagged': 'bool',\\n 'is_monitored': 'bool',\\n 'filter_wrap_up_notes': 'bool',\\n 'match_all': 'bool'\\n }\\n\\n self.attribute_map = {\\n 'is_waiting': 'isWaiting',\\n 'is_active': 'isActive',\\n 'is_acd': 'isAcd',\\n 'is_preferred': 'isPreferred',\\n 'is_screenshare': 'isScreenshare',\\n 'is_cobrowse': 'isCobrowse',\\n 'is_voicemail': 'isVoicemail',\\n 'is_flagged': 'isFlagged',\\n 'is_monitored': 'isMonitored',\\n 'filter_wrap_up_notes': 'filterWrapUpNotes',\\n 'match_all': 'matchAll'\\n }\\n\\n self._is_waiting = None\\n self._is_active = None\\n self._is_acd = None\\n self._is_preferred = None\\n self._is_screenshare = None\\n self._is_cobrowse = None\\n self._is_voicemail = None\\n self._is_flagged = None\\n self._is_monitored = None\\n self._filter_wrap_up_notes = None\\n self._match_all = None\",\n \"def grpc_settings(self) -> 'outputs.NotificationEndpointGrpcSettingsResponse':\\n return pulumi.get(self, \\\"grpc_settings\\\")\",\n \"def get_settings():\\n return SettingCollection.build()\",\n \"def create_settings_command(\\n settings_cls: type[BaseCustomSettings], logger: logging.Logger | None = None\\n) -> Callable:\\n\\n assert issubclass(settings_cls, BaseCustomSettings) # nosec\\n assert settings_cls != BaseCustomSettings # nosec\\n\\n if logger is None:\\n logger = logging.getLogger(__name__)\\n\\n def settings(\\n as_json: bool = False,\\n as_json_schema: bool = False,\\n compact: bool = typer.Option(False, help=\\\"Print compact form\\\"),\\n verbose: bool = False,\\n show_secrets: bool = False,\\n exclude_unset: bool = typer.Option(\\n False,\\n help=\\\"displays settings that were explicitly set\\\"\\n \\\"This represents current config (i.e. required+ defaults overriden).\\\",\\n ),\\n ):\\n \\\"\\\"\\\"Resolves settings and prints envfile\\\"\\\"\\\"\\n\\n if as_json_schema:\\n typer.echo(settings_cls.schema_json(indent=0 if compact else 2))\\n return\\n\\n try:\\n settings_obj = settings_cls.create_from_envs()\\n\\n except ValidationError as err:\\n settings_schema = settings_cls.schema_json(indent=2)\\n\\n assert logger is not None # nosec\\n logger.error(\\n \\\"Invalid settings. \\\"\\n \\\"Typically this is due to an environment variable missing or misspelled :\\\\n%s\\\",\\n \\\"\\\\n\\\".join(\\n [\\n HEADER_STR.format(\\\"detail\\\"),\\n str(err),\\n HEADER_STR.format(\\\"environment variables\\\"),\\n pformat(\\n {\\n k: v\\n for k, v in dict(os.environ).items()\\n if k.upper() == k\\n }\\n ),\\n HEADER_STR.format(\\\"json-schema\\\"),\\n settings_schema,\\n ]\\n ),\\n exc_info=False,\\n )\\n raise\\n\\n pydantic_export_options: dict[str, Any] = {\\\"exclude_unset\\\": exclude_unset}\\n if show_secrets:\\n # NOTE: this option is for json-only\\n pydantic_export_options[\\\"encoder\\\"] = create_json_encoder_wo_secrets(\\n settings_cls\\n )\\n\\n if as_json:\\n print_as_json(settings_obj, compact=compact, **pydantic_export_options)\\n else:\\n print_as_envfile(\\n settings_obj,\\n compact=compact,\\n verbose=verbose,\\n show_secrets=show_secrets,\\n **pydantic_export_options,\\n )\\n\\n return settings\",\n \"def test_settingmodel_init():\\n SettingsModel()\",\n \"def get_report_config(self, type: Type, id: str) -> Dict[str, Any]:\\n return self.get_document(type, id)\",\n \"def test_create_hyperflex_ucsm_config_policy(self):\\n pass\",\n \"def __init__(self, **kwargs):\\n self.swagger_types = {\\n 'key': 'str',\\n 'display_name': 'str',\\n 'description': 'str',\\n 'glossary_key': 'str',\\n 'parent_term_key': 'str',\\n 'is_allowed_to_have_child_terms': 'bool',\\n 'path': 'str',\\n 'lifecycle_state': 'str',\\n 'time_created': 'datetime',\\n 'time_updated': 'datetime',\\n 'created_by_id': 'str',\\n 'updated_by_id': 'str',\\n 'owner': 'str',\\n 'workflow_status': 'str',\\n 'uri': 'str',\\n 'associated_object_count': 'int',\\n 'associated_objects': 'list[TermAssociatedObject]'\\n }\\n\\n self.attribute_map = {\\n 'key': 'key',\\n 'display_name': 'displayName',\\n 'description': 'description',\\n 'glossary_key': 'glossaryKey',\\n 'parent_term_key': 'parentTermKey',\\n 'is_allowed_to_have_child_terms': 'isAllowedToHaveChildTerms',\\n 'path': 'path',\\n 'lifecycle_state': 'lifecycleState',\\n 'time_created': 'timeCreated',\\n 'time_updated': 'timeUpdated',\\n 'created_by_id': 'createdById',\\n 'updated_by_id': 'updatedById',\\n 'owner': 'owner',\\n 'workflow_status': 'workflowStatus',\\n 'uri': 'uri',\\n 'associated_object_count': 'associatedObjectCount',\\n 'associated_objects': 'associatedObjects'\\n }\\n\\n self._key = None\\n self._display_name = None\\n self._description = None\\n self._glossary_key = None\\n self._parent_term_key = None\\n self._is_allowed_to_have_child_terms = None\\n self._path = None\\n self._lifecycle_state = None\\n self._time_created = None\\n self._time_updated = None\\n self._created_by_id = None\\n self._updated_by_id = None\\n self._owner = None\\n self._workflow_status = None\\n self._uri = None\\n self._associated_object_count = None\\n self._associated_objects = None\",\n \"def lic_type():\\n return VocabularyType.create(id='licenses', pid_type='lic')\",\n \"async def update_trace_settings(\\n self,\\n model_name: str = ...,\\n settings: dict[str, t.Any] = ...,\\n headers: dict[str, t.Any] = ...,\\n as_json: t.Literal[False] = ...,\\n ) -> service_pb2.TraceSettingResponse:\\n ...\",\n \"def custom_openapi() -> Dict:\\n if app.openapi_schema:\\n return app.openapi_schema\\n openapi_schema = get_openapi(\\n title=\\\"The GenomicMedLab Cool Seq Tool\\\",\\n version=__version__,\\n description=\\\"Common Operations On Lots-of Sequences Tool.\\\",\\n routes=app.routes\\n )\\n\\n openapi_schema[\\\"info\\\"][\\\"contact\\\"] = {\\n \\\"name\\\": \\\"Alex H. Wagner\\\",\\n \\\"email\\\": \\\"Alex.Wagner@nationwidechildrens.org\\\",\\n \\\"url\\\": \\\"https://www.nationwidechildrens.org/specialties/institute-for-genomic-medicine/research-labs/wagner-lab\\\" # noqa: E501\\n }\\n app.openapi_schema = openapi_schema\\n return app.openapi_schema\",\n \"def init_api(settings):\\n dirname = os.path.dirname(__file__)\\n while len(dirname) > 1:\\n p = os.path.join(dirname, 'cacerts.txt')\\n\\n if os.path.exists(p):\\n cclib.CA_CERTS = p\\n break\\n\\n dirname = os.path.dirname(dirname)\\n return cclib.API(token=read_tokenfile(settings),\\n url=settings.api_url,\\n token_source_url=settings.token_source_url,\\n register_addon_url=settings.register_addon_url,\\n encode_email=settings.encode_email)\",\n \"def __init__(self, jsondict=None, strict=True):\\n \\n self.description = None\\n \\\"\\\"\\\" Description of capability.\\n List of `CodeableConcept` items (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n self.type = None\\n \\\"\\\"\\\" Type of capability.\\n Type `CodeableConcept` (represented as `dict` in JSON). \\\"\\\"\\\"\\n \\n super(DeviceDefinitionCapability, self).__init__(jsondict=jsondict, strict=strict)\",\n \"async def getConfigurationByType(self, type=None):\\n payload = {}\\n \\n if type:\\n payload[\\\"type\\\"] = type\\n \\n\\n # Parameter validation\\n schema = CatalogValidator.getConfigurationByType()\\n schema.dump(schema.load(payload))\\n \\n\\n url_with_params = await create_url_with_params(self._conf.domain, f\\\"/service/platform/catalog/v1.0/company/{self._conf.companyId}/application/{self.applicationId}/product-configuration/{type}/\\\", \\\"\\\"\\\"{\\\"required\\\":[{\\\"in\\\":\\\"path\\\",\\\"name\\\":\\\"company_id\\\",\\\"description\\\":\\\"A `company_id` is a unique identifier for a particular seller account.\\\",\\\"schema\\\":{\\\"type\\\":\\\"string\\\"},\\\"required\\\":true},{\\\"in\\\":\\\"path\\\",\\\"name\\\":\\\"application_id\\\",\\\"description\\\":\\\"A `application_id` is a unique identifier for a particular sale channel.\\\",\\\"schema\\\":{\\\"type\\\":\\\"string\\\"},\\\"required\\\":true},{\\\"in\\\":\\\"path\\\",\\\"name\\\":\\\"type\\\",\\\"description\\\":\\\"type can be brands, categories etc.\\\",\\\"schema\\\":{\\\"type\\\":\\\"string\\\"},\\\"required\\\":true}],\\\"optional\\\":[],\\\"query\\\":[],\\\"headers\\\":[],\\\"path\\\":[{\\\"in\\\":\\\"path\\\",\\\"name\\\":\\\"company_id\\\",\\\"description\\\":\\\"A `company_id` is a unique identifier for a particular seller account.\\\",\\\"schema\\\":{\\\"type\\\":\\\"string\\\"},\\\"required\\\":true},{\\\"in\\\":\\\"path\\\",\\\"name\\\":\\\"application_id\\\",\\\"description\\\":\\\"A `application_id` is a unique identifier for a particular sale channel.\\\",\\\"schema\\\":{\\\"type\\\":\\\"string\\\"},\\\"required\\\":true},{\\\"in\\\":\\\"path\\\",\\\"name\\\":\\\"type\\\",\\\"description\\\":\\\"type can be brands, categories etc.\\\",\\\"schema\\\":{\\\"type\\\":\\\"string\\\"},\\\"required\\\":true}]}\\\"\\\"\\\", type=type)\\n query_string = await create_query_string(type=type)\\n headers = {\\n \\\"Authorization\\\": \\\"Bearer \\\" + await self._conf.getAccessToken()\\n }\\n for h in self._conf.extraHeaders:\\n headers.update(h)\\n exclude_headers = []\\n for key, val in headers.items():\\n if not key.startswith(\\\"x-fp-\\\"):\\n exclude_headers.append(key)\\n return await AiohttpHelper().aiohttp_request(\\\"GET\\\", url_with_params, headers=get_headers_with_signature(self._conf.domain, \\\"get\\\", await create_url_without_domain(f\\\"/service/platform/catalog/v1.0/company/{self._conf.companyId}/application/{self.applicationId}/product-configuration/{type}/\\\", type=type), query_string, headers, \\\"\\\", exclude_headers=exclude_headers), data=\\\"\\\")\",\n \"def credential_list():\\n rows = safeisland.list_certificates()\\n certs = []\\n for row in rows:\\n# certs.append(row[\\\"cert\\\"])\\n certs.append({\\\"uuid\\\": row[\\\"uuid\\\"], \\\"cert\\\": row[\\\"cert\\\"]})\\n\\n return {\\\"payload\\\": certs}\",\n \"def __init__(__self__, *,\\n addon_configs: Optional[pulumi.Input[Mapping[str, Any]]] = None,\\n api_metadata_properties: Optional[pulumi.Input['GatewayApiMetadataPropertiesArgs']] = None,\\n apm_types: Optional[pulumi.Input[Sequence[pulumi.Input[Union[str, 'ApmType']]]]] = None,\\n client_auth: Optional[pulumi.Input['GatewayPropertiesClientAuthArgs']] = None,\\n cors_properties: Optional[pulumi.Input['GatewayCorsPropertiesArgs']] = None,\\n environment_variables: Optional[pulumi.Input['GatewayPropertiesEnvironmentVariablesArgs']] = None,\\n https_only: Optional[pulumi.Input[bool]] = None,\\n public: Optional[pulumi.Input[bool]] = None,\\n resource_requests: Optional[pulumi.Input['GatewayResourceRequestsArgs']] = None,\\n sso_properties: Optional[pulumi.Input['SsoPropertiesArgs']] = None):\\n if addon_configs is not None:\\n pulumi.set(__self__, \\\"addon_configs\\\", addon_configs)\\n if api_metadata_properties is not None:\\n pulumi.set(__self__, \\\"api_metadata_properties\\\", api_metadata_properties)\\n if apm_types is not None:\\n pulumi.set(__self__, \\\"apm_types\\\", apm_types)\\n if client_auth is not None:\\n pulumi.set(__self__, \\\"client_auth\\\", client_auth)\\n if cors_properties is not None:\\n pulumi.set(__self__, \\\"cors_properties\\\", cors_properties)\\n if environment_variables is not None:\\n pulumi.set(__self__, \\\"environment_variables\\\", environment_variables)\\n if https_only is None:\\n https_only = False\\n if https_only is not None:\\n pulumi.set(__self__, \\\"https_only\\\", https_only)\\n if public is None:\\n public = False\\n if public is not None:\\n pulumi.set(__self__, \\\"public\\\", public)\\n if resource_requests is not None:\\n pulumi.set(__self__, \\\"resource_requests\\\", resource_requests)\\n if sso_properties is not None:\\n pulumi.set(__self__, \\\"sso_properties\\\", sso_properties)\",\n \"def __init__(self, config):\\n super().__init__(config)\\n self.collector_host = config.get(\\\"collector_host\\\")\\n self.schedds = config.get(\\\"schedds\\\", [None])\\n self.condor_config = config.get(\\\"condor_config\\\")\\n self.constraint = config.get(\\\"constraint\\\", True)\\n self.classad_attrs = config.get(\\\"classad_attrs\\\")\\n self.correction_map = config.get(\\\"correction_map\\\")\",\n \"def _model_structure(self):\\n self.model_structure = {\\n 'title': str,\\n 'description': str,\\n 'tags': [str],\\n 'references': [str],\\n 'categories': [int],\\n 'authors': [dict],\\n 'defined_type': str,\\n 'funding': str,\\n 'license': str\\n }\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'id': 'str',\\n 'name': 'str',\\n 'channel_id': 'str',\\n 'channel_secret': 'str',\\n 'switcher_secret': 'str',\\n 'service_code': 'str',\\n 'self_uri': 'str'\\n }\\n\\n self.attribute_map = {\\n 'id': 'id',\\n 'name': 'name',\\n 'channel_id': 'channelId',\\n 'channel_secret': 'channelSecret',\\n 'switcher_secret': 'switcherSecret',\\n 'service_code': 'serviceCode',\\n 'self_uri': 'selfUri'\\n }\\n\\n self._id = None\\n self._name = None\\n self._channel_id = None\\n self._channel_secret = None\\n self._switcher_secret = None\\n self._service_code = None\\n self._self_uri = None\",\n \"def __init__(__self__,\\n resource_name: str,\\n args: ServerCertificateArgs,\\n opts: Optional[pulumi.ResourceOptions] = None):\\n ...\",\n \"def CreateOrUpdateAWSSettings(self, body):\\n # [POST] https://assets.falcon.crowdstrike.com/support/api/swagger.html#/cloud-connect-aws/CreateOrUpdateAWSSettings\\n FULL_URL = self.base_url+'/cloud-connect-aws/entities/settings/v1'\\n HEADERS = self.headers\\n BODY = body\\n result = self.Result()\\n try:\\n response = requests.request(\\\"POST\\\", FULL_URL, json=BODY, headers=HEADERS, verify=False)\\n returned = result(response.status_code, response.headers, response.json())\\n except Exception as e:\\n returned = result(500, {}, str(e))\\n \\n return returned\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'id_template_notificacao': 'int',\\n 'destinatarios': 'list[str]',\\n 'anexos': 'list[AnexoNotificacaoEmailRequest]',\\n 'parametros_conteudo': 'dict(str, object)'\\n }\\n\\n self.attribute_map = {\\n 'id_template_notificacao': 'idTemplateNotificacao',\\n 'destinatarios': 'destinatarios',\\n 'anexos': 'anexos',\\n 'parametros_conteudo': 'parametrosConteudo'\\n }\\n\\n self._id_template_notificacao = None\\n self._destinatarios = None\\n self._anexos = None\\n self._parametros_conteudo = None\",\n \"def test_create_hyperflex_vcenter_config_policy(self):\\n pass\",\n \"def settings(self):\\n return {}\",\n \"def to_dict(self):\\n result = {}\\n\\n for attr, _ in six.iteritems(self.swagger_types):\\n value = getattr(self, attr)\\n if isinstance(value, list):\\n result[attr] = list(map(\\n lambda x: x.to_dict() if hasattr(x, \\\"to_dict\\\") else x,\\n value\\n ))\\n elif hasattr(value, \\\"to_dict\\\"):\\n result[attr] = value.to_dict()\\n elif isinstance(value, dict):\\n result[attr] = dict(map(\\n lambda item: (item[0], item[1].to_dict())\\n if hasattr(item[1], \\\"to_dict\\\") else item,\\n value.items()\\n ))\\n else:\\n result[attr] = value\\n if issubclass(ChanPlanExplicit, dict):\\n for key, value in self.items():\\n result[key] = value\\n\\n return result\",\n \"def test_get_rule_settings(self):\\n # Basic passing test\\n rule_settings_params = {'agency_code': '097', 'file': 'B'}\\n response = self.app.get('/v1/rule_settings/', rule_settings_params, headers={'x-session-id': self.session_id})\\n\\n self.assertEqual(response.status_code, 200)\\n assert {'errors', 'warnings'} <= set(response.json.keys())\",\n \"def __init__(__self__, *,\\n auth_type: pulumi.Input[str],\\n ca_cert_resource_id: Optional[pulumi.Input[str]] = None):\\n pulumi.set(__self__, \\\"auth_type\\\", 'Public')\\n if ca_cert_resource_id is not None:\\n pulumi.set(__self__, \\\"ca_cert_resource_id\\\", ca_cert_resource_id)\",\n \"def __init__(self):\\n super(sppasAnnotationsSettings, self).__init__()\\n self.__dict__ = dict(\\n error=-1,\\n ok=0,\\n warning=1,\\n ignore=2,\\n info=3,\\n\\n extension=\\\".xra\\\",\\n\\n # all the types of the annotations implemented into SPPAS\\n types=(\\\"STANDALONE\\\", \\\"SPEAKER\\\", \\\"INTERACTION\\\"),\\n\\n # standard iso639-3 code for an undetermined language.\\n UNDETERMINED=\\\"und\\\"\\n\\n )\",\n \"def test_object_model_with_ref_props(self):\\n from petstore_api.model import object_model_with_ref_props\\n endpoint = self.api.object_model_with_ref_props\\n assert endpoint.openapi_types['body'] == (object_model_with_ref_props.ObjectModelWithRefProps,)\\n assert endpoint.settings['response_type'] == (object_model_with_ref_props.ObjectModelWithRefProps,)\",\n \"def to_dict(self):\\n result = {}\\n\\n for attr, _ in six.iteritems(self.swagger_types):\\n value = getattr(self, attr)\\n if isinstance(value, list):\\n result[attr] = list(\\n map(lambda x: x.to_dict() if hasattr(x, \\\"to_dict\\\") else x, value)\\n )\\n elif hasattr(value, \\\"to_dict\\\"):\\n result[attr] = value.to_dict()\\n elif isinstance(value, dict):\\n result[attr] = dict(\\n map(\\n lambda item: (item[0], item[1].to_dict())\\n if hasattr(item[1], \\\"to_dict\\\")\\n else item,\\n value.items(),\\n )\\n )\\n else:\\n result[attr] = value\\n if issubclass(FtsSftpSettings, dict):\\n for key, value in self.items():\\n result[key] = value\\n\\n return result\",\n \"def __init__(self, settings):\\n self._settings = settings\",\n \"def __init__(__self__, *,\\n label: pulumi.Input[str],\\n type: pulumi.Input[str],\\n accessibility_error_redirect_url: Optional[pulumi.Input[str]] = None,\\n accessibility_login_redirect_url: Optional[pulumi.Input[str]] = None,\\n accessibility_self_service: Optional[pulumi.Input[bool]] = None,\\n admin_note: Optional[pulumi.Input[str]] = None,\\n app_links_json: Optional[pulumi.Input[str]] = None,\\n app_settings_json: Optional[pulumi.Input[str]] = None,\\n authentication_policy: Optional[pulumi.Input[str]] = None,\\n auto_key_rotation: Optional[pulumi.Input[bool]] = None,\\n auto_submit_toolbar: Optional[pulumi.Input[bool]] = None,\\n client_basic_secret: Optional[pulumi.Input[str]] = None,\\n client_id: Optional[pulumi.Input[str]] = None,\\n client_uri: Optional[pulumi.Input[str]] = None,\\n consent_method: Optional[pulumi.Input[str]] = None,\\n enduser_note: Optional[pulumi.Input[str]] = None,\\n grant_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n groups_claim: Optional[pulumi.Input['OAuthGroupsClaimArgs']] = None,\\n hide_ios: Optional[pulumi.Input[bool]] = None,\\n hide_web: Optional[pulumi.Input[bool]] = None,\\n implicit_assignment: Optional[pulumi.Input[bool]] = None,\\n issuer_mode: Optional[pulumi.Input[str]] = None,\\n jwks: Optional[pulumi.Input[Sequence[pulumi.Input['OAuthJwkArgs']]]] = None,\\n jwks_uri: Optional[pulumi.Input[str]] = None,\\n login_mode: Optional[pulumi.Input[str]] = None,\\n login_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n login_uri: Optional[pulumi.Input[str]] = None,\\n logo: Optional[pulumi.Input[str]] = None,\\n logo_uri: Optional[pulumi.Input[str]] = None,\\n omit_secret: Optional[pulumi.Input[bool]] = None,\\n pkce_required: Optional[pulumi.Input[bool]] = None,\\n policy_uri: Optional[pulumi.Input[str]] = None,\\n post_logout_redirect_uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n profile: Optional[pulumi.Input[str]] = None,\\n redirect_uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n refresh_token_leeway: Optional[pulumi.Input[int]] = None,\\n refresh_token_rotation: Optional[pulumi.Input[str]] = None,\\n response_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n status: Optional[pulumi.Input[str]] = None,\\n token_endpoint_auth_method: Optional[pulumi.Input[str]] = None,\\n tos_uri: Optional[pulumi.Input[str]] = None,\\n user_name_template: Optional[pulumi.Input[str]] = None,\\n user_name_template_push_status: Optional[pulumi.Input[str]] = None,\\n user_name_template_suffix: Optional[pulumi.Input[str]] = None,\\n user_name_template_type: Optional[pulumi.Input[str]] = None,\\n wildcard_redirect: Optional[pulumi.Input[str]] = None):\\n pulumi.set(__self__, \\\"label\\\", label)\\n pulumi.set(__self__, \\\"type\\\", type)\\n if accessibility_error_redirect_url is not None:\\n pulumi.set(__self__, \\\"accessibility_error_redirect_url\\\", accessibility_error_redirect_url)\\n if accessibility_login_redirect_url is not None:\\n pulumi.set(__self__, \\\"accessibility_login_redirect_url\\\", accessibility_login_redirect_url)\\n if accessibility_self_service is not None:\\n pulumi.set(__self__, \\\"accessibility_self_service\\\", accessibility_self_service)\\n if admin_note is not None:\\n pulumi.set(__self__, \\\"admin_note\\\", admin_note)\\n if app_links_json is not None:\\n pulumi.set(__self__, \\\"app_links_json\\\", app_links_json)\\n if app_settings_json is not None:\\n pulumi.set(__self__, \\\"app_settings_json\\\", app_settings_json)\\n if authentication_policy is not None:\\n pulumi.set(__self__, \\\"authentication_policy\\\", authentication_policy)\\n if auto_key_rotation is not None:\\n pulumi.set(__self__, \\\"auto_key_rotation\\\", auto_key_rotation)\\n if auto_submit_toolbar is not None:\\n pulumi.set(__self__, \\\"auto_submit_toolbar\\\", auto_submit_toolbar)\\n if client_basic_secret is not None:\\n pulumi.set(__self__, \\\"client_basic_secret\\\", client_basic_secret)\\n if client_id is not None:\\n pulumi.set(__self__, \\\"client_id\\\", client_id)\\n if client_uri is not None:\\n pulumi.set(__self__, \\\"client_uri\\\", client_uri)\\n if consent_method is not None:\\n pulumi.set(__self__, \\\"consent_method\\\", consent_method)\\n if enduser_note is not None:\\n pulumi.set(__self__, \\\"enduser_note\\\", enduser_note)\\n if grant_types is not None:\\n pulumi.set(__self__, \\\"grant_types\\\", grant_types)\\n if groups_claim is not None:\\n pulumi.set(__self__, \\\"groups_claim\\\", groups_claim)\\n if hide_ios is not None:\\n pulumi.set(__self__, \\\"hide_ios\\\", hide_ios)\\n if hide_web is not None:\\n pulumi.set(__self__, \\\"hide_web\\\", hide_web)\\n if implicit_assignment is not None:\\n pulumi.set(__self__, \\\"implicit_assignment\\\", implicit_assignment)\\n if issuer_mode is not None:\\n pulumi.set(__self__, \\\"issuer_mode\\\", issuer_mode)\\n if jwks is not None:\\n pulumi.set(__self__, \\\"jwks\\\", jwks)\\n if jwks_uri is not None:\\n pulumi.set(__self__, \\\"jwks_uri\\\", jwks_uri)\\n if login_mode is not None:\\n pulumi.set(__self__, \\\"login_mode\\\", login_mode)\\n if login_scopes is not None:\\n pulumi.set(__self__, \\\"login_scopes\\\", login_scopes)\\n if login_uri is not None:\\n pulumi.set(__self__, \\\"login_uri\\\", login_uri)\\n if logo is not None:\\n pulumi.set(__self__, \\\"logo\\\", logo)\\n if logo_uri is not None:\\n pulumi.set(__self__, \\\"logo_uri\\\", logo_uri)\\n if omit_secret is not None:\\n pulumi.set(__self__, \\\"omit_secret\\\", omit_secret)\\n if pkce_required is not None:\\n pulumi.set(__self__, \\\"pkce_required\\\", pkce_required)\\n if policy_uri is not None:\\n pulumi.set(__self__, \\\"policy_uri\\\", policy_uri)\\n if post_logout_redirect_uris is not None:\\n pulumi.set(__self__, \\\"post_logout_redirect_uris\\\", post_logout_redirect_uris)\\n if profile is not None:\\n pulumi.set(__self__, \\\"profile\\\", profile)\\n if redirect_uris is not None:\\n pulumi.set(__self__, \\\"redirect_uris\\\", redirect_uris)\\n if refresh_token_leeway is not None:\\n pulumi.set(__self__, \\\"refresh_token_leeway\\\", refresh_token_leeway)\\n if refresh_token_rotation is not None:\\n pulumi.set(__self__, \\\"refresh_token_rotation\\\", refresh_token_rotation)\\n if response_types is not None:\\n pulumi.set(__self__, \\\"response_types\\\", response_types)\\n if status is not None:\\n pulumi.set(__self__, \\\"status\\\", status)\\n if token_endpoint_auth_method is not None:\\n pulumi.set(__self__, \\\"token_endpoint_auth_method\\\", token_endpoint_auth_method)\\n if tos_uri is not None:\\n pulumi.set(__self__, \\\"tos_uri\\\", tos_uri)\\n if user_name_template is not None:\\n pulumi.set(__self__, \\\"user_name_template\\\", user_name_template)\\n if user_name_template_push_status is not None:\\n pulumi.set(__self__, \\\"user_name_template_push_status\\\", user_name_template_push_status)\\n if user_name_template_suffix is not None:\\n pulumi.set(__self__, \\\"user_name_template_suffix\\\", user_name_template_suffix)\\n if user_name_template_type is not None:\\n pulumi.set(__self__, \\\"user_name_template_type\\\", user_name_template_type)\\n if wildcard_redirect is not None:\\n pulumi.set(__self__, \\\"wildcard_redirect\\\", wildcard_redirect)\",\n \"def openapi_types():\\n return {\\n \\\"account\\\": (str,), # noqa: E501\\n \\\"address_city\\\": (str,), # noqa: E501\\n \\\"address_country\\\": (str,), # noqa: E501\\n \\\"address_line1\\\": (str,), # noqa: E501\\n \\\"address_line1_check\\\": (str,), # noqa: E501\\n \\\"address_line2\\\": (str,), # noqa: E501\\n \\\"address_state\\\": (str,), # noqa: E501\\n \\\"address_zip\\\": (str,), # noqa: E501\\n \\\"address_zip_check\\\": (str,), # noqa: E501\\n \\\"available_payout_methods\\\": ([str],), # noqa: E501\\n \\\"brand\\\": (str,), # noqa: E501\\n \\\"country\\\": (str,), # noqa: E501\\n \\\"currency\\\": (str,), # noqa: E501\\n \\\"customer\\\": (str,), # noqa: E501\\n \\\"cvc_check\\\": (str,), # noqa: E501\\n \\\"default_for_currency\\\": (bool,), # noqa: E501\\n \\\"description\\\": (str,), # noqa: E501\\n \\\"dynamic_last4\\\": (str,), # noqa: E501\\n \\\"exp_month\\\": (int,), # noqa: E501\\n \\\"exp_year\\\": (int,), # noqa: E501\\n \\\"fingerprint\\\": (str,), # noqa: E501\\n \\\"funding\\\": (str,), # noqa: E501\\n \\\"id\\\": (str,), # noqa: E501\\n \\\"iin\\\": (str,), # noqa: E501\\n \\\"instance_url\\\": (str,), # noqa: E501\\n \\\"issuer\\\": (str,), # noqa: E501\\n \\\"last4\\\": (str,), # noqa: E501\\n \\\"metadata\\\": ({str: (str,)},), # noqa: E501\\n \\\"name\\\": (str,), # noqa: E501\\n \\\"object\\\": (str,), # noqa: E501\\n \\\"recipient\\\": (str,), # noqa: E501\\n \\\"status\\\": (str,), # noqa: E501\\n \\\"three_d_secure\\\": (three_d_secure.ThreeDSecure,), # noqa: E501\\n \\\"tokenization_method\\\": (str,), # noqa: E501\\n \\\"type\\\": (str,), # noqa: E501\\n }\",\n \"def client_settings():\\n return CLIENT_SETTINGS\",\n \"def __init__(self, com_adobe_aem_screens_player_pingfrequency: ConfigNodePropertyInteger=None, com_adobe_aem_screens_device_pasword_specialchars: ConfigNodePropertyString=None, com_adobe_aem_screens_device_pasword_minlowercasechars: ConfigNodePropertyInteger=None, com_adobe_aem_screens_device_pasword_minuppercasechars: ConfigNodePropertyInteger=None, com_adobe_aem_screens_device_pasword_minnumberchars: ConfigNodePropertyInteger=None, com_adobe_aem_screens_device_pasword_minspecialchars: ConfigNodePropertyInteger=None, com_adobe_aem_screens_device_pasword_minlength: ConfigNodePropertyInteger=None): # noqa: E501\\n self.openapi_types = {\\n 'com_adobe_aem_screens_player_pingfrequency': ConfigNodePropertyInteger,\\n 'com_adobe_aem_screens_device_pasword_specialchars': ConfigNodePropertyString,\\n 'com_adobe_aem_screens_device_pasword_minlowercasechars': ConfigNodePropertyInteger,\\n 'com_adobe_aem_screens_device_pasword_minuppercasechars': ConfigNodePropertyInteger,\\n 'com_adobe_aem_screens_device_pasword_minnumberchars': ConfigNodePropertyInteger,\\n 'com_adobe_aem_screens_device_pasword_minspecialchars': ConfigNodePropertyInteger,\\n 'com_adobe_aem_screens_device_pasword_minlength': ConfigNodePropertyInteger\\n }\\n\\n self.attribute_map = {\\n 'com_adobe_aem_screens_player_pingfrequency': 'com.adobe.aem.screens.player.pingfrequency',\\n 'com_adobe_aem_screens_device_pasword_specialchars': 'com.adobe.aem.screens.device.pasword.specialchars',\\n 'com_adobe_aem_screens_device_pasword_minlowercasechars': 'com.adobe.aem.screens.device.pasword.minlowercasechars',\\n 'com_adobe_aem_screens_device_pasword_minuppercasechars': 'com.adobe.aem.screens.device.pasword.minuppercasechars',\\n 'com_adobe_aem_screens_device_pasword_minnumberchars': 'com.adobe.aem.screens.device.pasword.minnumberchars',\\n 'com_adobe_aem_screens_device_pasword_minspecialchars': 'com.adobe.aem.screens.device.pasword.minspecialchars',\\n 'com_adobe_aem_screens_device_pasword_minlength': 'com.adobe.aem.screens.device.pasword.minlength'\\n }\\n\\n self._com_adobe_aem_screens_player_pingfrequency = com_adobe_aem_screens_player_pingfrequency\\n self._com_adobe_aem_screens_device_pasword_specialchars = com_adobe_aem_screens_device_pasword_specialchars\\n self._com_adobe_aem_screens_device_pasword_minlowercasechars = com_adobe_aem_screens_device_pasword_minlowercasechars\\n self._com_adobe_aem_screens_device_pasword_minuppercasechars = com_adobe_aem_screens_device_pasword_minuppercasechars\\n self._com_adobe_aem_screens_device_pasword_minnumberchars = com_adobe_aem_screens_device_pasword_minnumberchars\\n self._com_adobe_aem_screens_device_pasword_minspecialchars = com_adobe_aem_screens_device_pasword_minspecialchars\\n self._com_adobe_aem_screens_device_pasword_minlength = com_adobe_aem_screens_device_pasword_minlength\",\n \"def SecurityPolicyFromFile(input_file, messages, file_format):\\n\\n if file_format == 'yaml':\\n parsed_security_policy = yaml.load(input_file)\\n else:\\n try:\\n parsed_security_policy = json.load(input_file)\\n except ValueError as e:\\n raise exceptions.BadFileException('Error parsing JSON: {0}'.format(\\n six.text_type(e)))\\n\\n security_policy = messages.SecurityPolicy()\\n if 'description' in parsed_security_policy:\\n security_policy.description = parsed_security_policy['description']\\n if 'fingerprint' in parsed_security_policy:\\n security_policy.fingerprint = base64.urlsafe_b64decode(\\n parsed_security_policy['fingerprint'].encode('ascii'))\\n if 'type' in parsed_security_policy:\\n security_policy.type = (\\n messages.SecurityPolicy.TypeValueValuesEnum(\\n parsed_security_policy['type']))\\n if 'cloudArmorConfig' in parsed_security_policy:\\n security_policy.cloudArmorConfig = messages.SecurityPolicyCloudArmorConfig(\\n enableMl=parsed_security_policy['cloudArmorConfig']['enableMl'])\\n if 'adaptiveProtectionConfig' in parsed_security_policy:\\n security_policy.adaptiveProtectionConfig = (\\n messages.SecurityPolicyAdaptiveProtectionConfig(\\n layer7DdosDefenseConfig=messages\\n .SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig(\\n enable=parsed_security_policy['adaptiveProtectionConfig']\\n ['layer7DdosDefenseConfig']['enable']),))\\n if 'autoDeployConfig' in parsed_security_policy['adaptiveProtectionConfig']:\\n security_policy.adaptiveProtectionConfig.autoDeployConfig = (\\n messages.SecurityPolicyAdaptiveProtectionConfigAutoDeployConfig())\\n if 'loadThreshold' in parsed_security_policy['adaptiveProtectionConfig'][\\n 'autoDeployConfig']:\\n security_policy.adaptiveProtectionConfig.autoDeployConfig.loadThreshold = (\\n parsed_security_policy['adaptiveProtectionConfig']\\n ['autoDeployConfig']['loadThreshold'])\\n if 'confidenceThreshold' in parsed_security_policy[\\n 'adaptiveProtectionConfig']['autoDeployConfig']:\\n security_policy.adaptiveProtectionConfig.autoDeployConfig.confidenceThreshold = (\\n parsed_security_policy['adaptiveProtectionConfig']\\n ['autoDeployConfig']['confidenceThreshold'])\\n if 'impactedBaselineThreshold' in parsed_security_policy[\\n 'adaptiveProtectionConfig']['autoDeployConfig']:\\n security_policy.adaptiveProtectionConfig.autoDeployConfig.impactedBaselineThreshold = (\\n parsed_security_policy['adaptiveProtectionConfig']\\n ['autoDeployConfig']['impactedBaselineThreshold'])\\n if 'expirationSec' in parsed_security_policy['adaptiveProtectionConfig'][\\n 'autoDeployConfig']:\\n security_policy.adaptiveProtectionConfig.autoDeployConfig.expirationSec = (\\n parsed_security_policy['adaptiveProtectionConfig']\\n ['autoDeployConfig']['expirationSec'])\\n if 'ruleVisibility' in parsed_security_policy['adaptiveProtectionConfig'][\\n 'layer7DdosDefenseConfig']:\\n security_policy.adaptiveProtectionConfig.layer7DdosDefenseConfig.ruleVisibility = (\\n messages.SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig\\n .RuleVisibilityValueValuesEnum(\\n parsed_security_policy['adaptiveProtectionConfig']\\n ['layer7DdosDefenseConfig']['ruleVisibility']))\\n if 'advancedOptionsConfig' in parsed_security_policy:\\n advanced_options_config = parsed_security_policy['advancedOptionsConfig']\\n security_policy.advancedOptionsConfig = (\\n messages.SecurityPolicyAdvancedOptionsConfig())\\n if 'jsonParsing' in advanced_options_config:\\n security_policy.advancedOptionsConfig.jsonParsing = (\\n messages.SecurityPolicyAdvancedOptionsConfig\\n .JsonParsingValueValuesEnum(\\n advanced_options_config['jsonParsing']))\\n if 'jsonCustomConfig' in advanced_options_config:\\n security_policy.advancedOptionsConfig.jsonCustomConfig = (\\n messages.SecurityPolicyAdvancedOptionsConfigJsonCustomConfig(\\n contentTypes=advanced_options_config\\n ['jsonCustomConfig'].get('contentTypes', [])))\\n if 'logLevel' in advanced_options_config:\\n security_policy.advancedOptionsConfig.logLevel = (\\n messages.SecurityPolicyAdvancedOptionsConfig.LogLevelValueValuesEnum(\\n advanced_options_config['logLevel']))\\n if 'userIpRequestHeaders' in advanced_options_config:\\n security_policy.advancedOptionsConfig.userIpRequestHeaders = (\\n advanced_options_config['userIpRequestHeaders'])\\n if 'ddosProtectionConfig' in parsed_security_policy:\\n security_policy.ddosProtectionConfig = (\\n messages.SecurityPolicyDdosProtectionConfig(\\n ddosProtection=messages.SecurityPolicyDdosProtectionConfig\\n .DdosProtectionValueValuesEnum(\\n parsed_security_policy['ddosProtectionConfig']\\n ['ddosProtection'])))\\n if 'recaptchaOptionsConfig' in parsed_security_policy:\\n security_policy.recaptchaOptionsConfig = (\\n messages.SecurityPolicyRecaptchaOptionsConfig())\\n if 'redirectSiteKey' in parsed_security_policy['recaptchaOptionsConfig']:\\n security_policy.recaptchaOptionsConfig.redirectSiteKey = (\\n parsed_security_policy['recaptchaOptionsConfig']['redirectSiteKey'])\\n\\n if 'userDefinedFields' in parsed_security_policy:\\n user_defined_fields = []\\n for udf in parsed_security_policy['userDefinedFields']:\\n user_defined_field = messages.SecurityPolicyUserDefinedField()\\n user_defined_field.name = udf['name']\\n user_defined_field.base = (\\n messages.SecurityPolicyUserDefinedField.BaseValueValuesEnum(\\n udf['base']\\n )\\n )\\n user_defined_field.offset = udf['offset']\\n user_defined_field.size = udf['size']\\n if 'mask' in udf:\\n user_defined_field.mask = udf['mask']\\n user_defined_fields.append(user_defined_field)\\n security_policy.userDefinedFields = user_defined_fields\\n\\n rules = []\\n for rule in parsed_security_policy['rules']:\\n security_policy_rule = messages.SecurityPolicyRule()\\n security_policy_rule.action = rule['action']\\n if 'description' in rule:\\n security_policy_rule.description = rule['description']\\n if 'match' in rule:\\n match = messages.SecurityPolicyRuleMatcher()\\n if 'versionedExpr' in rule['match']:\\n match.versionedExpr = ConvertToEnum(\\n rule['match']['versionedExpr'], messages\\n )\\n if 'expr' in rule['match']:\\n match.expr = messages.Expr(\\n expression=rule['match']['expr']['expression']\\n )\\n if 'exprOptions' in rule['match']:\\n expr_options = messages.SecurityPolicyRuleMatcherExprOptions()\\n if 'recaptchaOptions' in rule['match']['exprOptions']:\\n expr_options.recaptchaOptions = (\\n messages.SecurityPolicyRuleMatcherExprOptionsRecaptchaOptions(\\n actionTokenSiteKeys=rule['match']['exprOptions'][\\n 'recaptchaOptions'\\n ].get('actionTokenSiteKeys', []),\\n sessionTokenSiteKeys=rule['match']['exprOptions'][\\n 'recaptchaOptions'\\n ].get('sessionTokenSiteKeys', []),\\n )\\n )\\n match.exprOptions = expr_options\\n if 'config' in rule['match']:\\n if 'srcIpRanges' in rule['match']['config']:\\n match.config = messages.SecurityPolicyRuleMatcherConfig(\\n srcIpRanges=rule['match']['config']['srcIpRanges']\\n )\\n security_policy_rule.match = match\\n if 'networkMatch' in rule:\\n network_match = messages.SecurityPolicyRuleNetworkMatcher()\\n if 'userDefinedFields' in rule['networkMatch']:\\n user_defined_fields = []\\n for udf in rule['networkMatch']['userDefinedFields']:\\n user_defined_field_match = (\\n messages.SecurityPolicyRuleNetworkMatcherUserDefinedFieldMatch()\\n )\\n user_defined_field_match.name = udf['name']\\n user_defined_field_match.values = udf['values']\\n user_defined_fields.append(user_defined_field_match)\\n network_match.userDefinedFields = user_defined_fields\\n if 'srcIpRanges' in rule['networkMatch']:\\n network_match.srcIpRanges = rule['networkMatch']['srcIpRanges']\\n if 'destIpRanges' in rule['networkMatch']:\\n network_match.destIpRanges = rule['networkMatch']['destIpRanges']\\n if 'ipProtocols' in rule['networkMatch']:\\n network_match.ipProtocols = rule['networkMatch']['ipProtocols']\\n if 'srcPorts' in rule['networkMatch']:\\n network_match.srcPorts = rule['networkMatch']['srcPorts']\\n if 'destPorts' in rule['networkMatch']:\\n network_match.destPorts = rule['networkMatch']['destPorts']\\n if 'srcRegionCodes' in rule['networkMatch']:\\n network_match.srcRegionCodes = rule['networkMatch']['srcRegionCodes']\\n if 'srcAsns' in rule['networkMatch']:\\n network_match.srcAsns = rule['networkMatch']['srcAsns']\\n security_policy_rule.networkMatch = network_match\\n security_policy_rule.priority = int(rule['priority'])\\n if 'preview' in rule:\\n security_policy_rule.preview = rule['preview']\\n rules.append(security_policy_rule)\\n if 'redirectTarget' in rule:\\n security_policy_rule.redirectTarget = rule['redirectTarget']\\n if 'ruleNumber' in rule:\\n security_policy_rule.ruleNumber = int(rule['ruleNumber'])\\n if 'redirectOptions' in rule:\\n redirect_options = messages.SecurityPolicyRuleRedirectOptions()\\n if 'type' in rule['redirectOptions']:\\n redirect_options.type = (\\n messages.SecurityPolicyRuleRedirectOptions.TypeValueValuesEnum(\\n rule['redirectOptions']['type']))\\n if 'target' in rule['redirectOptions']:\\n redirect_options.target = rule['redirectOptions']['target']\\n security_policy_rule.redirectOptions = redirect_options\\n if 'headerAction' in rule:\\n header_action = messages.SecurityPolicyRuleHttpHeaderAction()\\n headers_in_rule = rule['headerAction'].get('requestHeadersToAdds', [])\\n headers_to_add = []\\n for header_to_add in headers_in_rule:\\n headers_to_add.append(\\n messages.SecurityPolicyRuleHttpHeaderActionHttpHeaderOption(\\n headerName=header_to_add['headerName'],\\n headerValue=header_to_add['headerValue']))\\n if headers_to_add:\\n header_action.requestHeadersToAdds = headers_to_add\\n security_policy_rule.headerAction = header_action\\n if 'rateLimitOptions' in rule:\\n rate_limit_options = rule['rateLimitOptions']\\n security_policy_rule.rateLimitOptions = (\\n messages.SecurityPolicyRuleRateLimitOptions(\\n rateLimitThreshold=messages\\n .SecurityPolicyRuleRateLimitOptionsThreshold(\\n count=rate_limit_options['rateLimitThreshold']['count'],\\n intervalSec=rate_limit_options['rateLimitThreshold']\\n ['intervalSec']),\\n conformAction=rate_limit_options['conformAction'],\\n exceedAction=rate_limit_options['exceedAction']))\\n if 'exceedActionRpcStatus' in rate_limit_options:\\n exceed_action_rpc_status = (\\n messages.SecurityPolicyRuleRateLimitOptionsRpcStatus()\\n )\\n if 'code' in rate_limit_options['exceedActionRpcStatus']:\\n exceed_action_rpc_status.code = rate_limit_options[\\n 'exceedActionRpcStatus']['code']\\n if 'message' in rate_limit_options['exceedActionRpcStatus']:\\n exceed_action_rpc_status.message = rate_limit_options[\\n 'exceedActionRpcStatus']['message']\\n security_policy_rule.rateLimitOptions.exceedActionRpcStatus = (\\n exceed_action_rpc_status\\n )\\n if 'exceedRedirectOptions' in rate_limit_options:\\n exceed_redirect_options = messages.SecurityPolicyRuleRedirectOptions()\\n if 'type' in rate_limit_options['exceedRedirectOptions']:\\n exceed_redirect_options.type = (\\n messages.SecurityPolicyRuleRedirectOptions.TypeValueValuesEnum(\\n rate_limit_options['exceedRedirectOptions']['type']))\\n if 'target' in rate_limit_options['exceedRedirectOptions']:\\n exceed_redirect_options.target = rate_limit_options[\\n 'exceedRedirectOptions']['target']\\n security_policy_rule.rateLimitOptions.exceedRedirectOptions = (\\n exceed_redirect_options)\\n if 'banThreshold' in rate_limit_options:\\n security_policy_rule.rateLimitOptions.banThreshold = (\\n messages.SecurityPolicyRuleRateLimitOptionsThreshold(\\n count=rate_limit_options['banThreshold']['count'],\\n intervalSec=rate_limit_options['banThreshold']['intervalSec']))\\n if 'banDurationSec' in rate_limit_options:\\n security_policy_rule.rateLimitOptions.banDurationSec = (\\n rate_limit_options['banDurationSec'])\\n if 'enforceOnKey' in rate_limit_options:\\n security_policy_rule.rateLimitOptions.enforceOnKey = (\\n messages.SecurityPolicyRuleRateLimitOptions\\n .EnforceOnKeyValueValuesEnum(rate_limit_options['enforceOnKey']))\\n if 'enforceOnKeyName' in rate_limit_options:\\n security_policy_rule.rateLimitOptions.enforceOnKeyName = (\\n rate_limit_options['enforceOnKeyName'])\\n if 'preconfiguredWafConfig' in rule:\\n preconfig_waf_config = messages.SecurityPolicyRulePreconfiguredWafConfig()\\n for exclusion in rule['preconfiguredWafConfig'].get('exclusions', []):\\n exclusion_to_add = (\\n messages.SecurityPolicyRulePreconfiguredWafConfigExclusion())\\n if 'targetRuleSet' in exclusion:\\n exclusion_to_add.targetRuleSet = exclusion['targetRuleSet']\\n for target_rule_id in exclusion.get('targetRuleIds', []):\\n exclusion_to_add.targetRuleIds.append(target_rule_id)\\n for request_header in exclusion.get('requestHeadersToExclude', []):\\n exclusion_to_add.requestHeadersToExclude.append(\\n ConvertPreconfigWafExclusionRequestField(request_header,\\n messages))\\n for request_cookie in exclusion.get('requestCookiesToExclude', []):\\n exclusion_to_add.requestCookiesToExclude.append(\\n ConvertPreconfigWafExclusionRequestField(request_cookie,\\n messages))\\n for request_query_param in exclusion.get('requestQueryParamsToExclude',\\n []):\\n exclusion_to_add.requestQueryParamsToExclude.append(\\n ConvertPreconfigWafExclusionRequestField(request_query_param,\\n messages))\\n for request_uri in exclusion.get('requestUrisToExclude', []):\\n exclusion_to_add.requestUrisToExclude.append(\\n ConvertPreconfigWafExclusionRequestField(request_uri, messages))\\n preconfig_waf_config.exclusions.append(exclusion_to_add)\\n security_policy_rule.preconfiguredWafConfig = preconfig_waf_config\\n\\n security_policy.rules = rules\\n\\n return security_policy\",\n \"def __init__(__self__,\\n resource_name: str,\\n args: CertificateArgs,\\n opts: Optional[pulumi.ResourceOptions] = None):\\n ...\",\n \"def to_dict(self):\\n result = {}\\n\\n for attr, _ in six.iteritems(self.swagger_types):\\n value = getattr(self, attr)\\n if isinstance(value, list):\\n result[attr] = list(map(\\n lambda x: x.to_dict() if hasattr(x, \\\"to_dict\\\") else x,\\n value\\n ))\\n elif hasattr(value, \\\"to_dict\\\"):\\n result[attr] = value.to_dict()\\n elif isinstance(value, dict):\\n result[attr] = dict(map(\\n lambda item: (item[0], item[1].to_dict())\\n if hasattr(item[1], \\\"to_dict\\\") else item,\\n value.items()\\n ))\\n else:\\n result[attr] = value\\n if issubclass(PortainerLDAPSettings, dict):\\n for key, value in self.items():\\n result[key] = value\\n\\n return result\",\n \"def settings(self) -> Optional[pulumi.Input['ConfigurationServiceSettingsArgs']]:\\n return pulumi.get(self, \\\"settings\\\")\",\n \"def encryption_settings_collection(self) -> Optional['outputs.EncryptionSettingsCollectionResponse']:\\n return pulumi.get(self, \\\"encryption_settings_collection\\\")\",\n \"def settings(self):\\n from hubspot3.settings import SettingsClient\\n\\n return SettingsClient(**self.auth, **self.options)\",\n \"def __init__(__self__,\\n resource_name: str,\\n args: SSLCertificateArgs,\\n opts: Optional[pulumi.ResourceOptions] = None):\\n ...\",\n \"def settings(self) -> Dict[str, Any]:\\n return {}\",\n \"def __init__(self, settings):\\n \\n # storing otmbs settings\\n self.settings = settings\",\n \"def __init__( settings={} ):\",\n \"def to_dict(self):\\n result = {}\\n\\n for attr, _ in six.iteritems(self.swagger_types):\\n value = getattr(self, attr)\\n if isinstance(value, list):\\n result[attr] = list(map(\\n lambda x: x.to_dict() if hasattr(x, \\\"to_dict\\\") else x,\\n value\\n ))\\n elif hasattr(value, \\\"to_dict\\\"):\\n result[attr] = value.to_dict()\\n elif isinstance(value, dict):\\n result[attr] = dict(map(\\n lambda item: (item[0], item[1].to_dict())\\n if hasattr(item[1], \\\"to_dict\\\") else item,\\n value.items()\\n ))\\n else:\\n result[attr] = value\\n if issubclass(RawDataSettingsV1, dict):\\n for key, value in self.items():\\n result[key] = value\\n\\n return result\",\n \"def __init__(self):\\n self.swagger_types = {\\n 'source_contact': 'AddressableEntityRef',\\n 'target_contact': 'AddressableEntityRef',\\n 'resulting_contact': 'AddressableEntityRef'\\n }\\n\\n self.attribute_map = {\\n 'source_contact': 'sourceContact',\\n 'target_contact': 'targetContact',\\n 'resulting_contact': 'resultingContact'\\n }\\n\\n self._source_contact = None\\n self._target_contact = None\\n self._resulting_contact = None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.51528734","0.49188662","0.48297343","0.4826368","0.4826368","0.48228797","0.4819829","0.47996086","0.4773806","0.4751501","0.47396463","0.4729209","0.47166255","0.4694356","0.46928954","0.46187517","0.46133664","0.46113682","0.4605297","0.46039793","0.45815492","0.45652682","0.45518842","0.45386362","0.45335993","0.45185843","0.4492622","0.44671535","0.44671535","0.44569376","0.44402635","0.44343877","0.44273782","0.44248655","0.4418796","0.44075567","0.44056225","0.43920624","0.43920624","0.43915415","0.43843538","0.43835598","0.43826148","0.43776152","0.43738687","0.43676823","0.43672884","0.43546328","0.43410403","0.4331933","0.43213588","0.43109053","0.43105468","0.43046385","0.4297891","0.42975804","0.42814678","0.42775372","0.42759514","0.42717448","0.42632934","0.42616928","0.42323282","0.423","0.4226542","0.42190614","0.42026317","0.41945434","0.41900796","0.41886762","0.41818112","0.4180672","0.41786185","0.41759932","0.4174688","0.4173559","0.41734484","0.41626653","0.41616225","0.4158853","0.415136","0.41454726","0.41451663","0.41385615","0.41382977","0.41366988","0.41355997","0.4134131","0.41304764","0.41244233","0.41239828","0.41235584","0.41217807","0.41153744","0.4113573","0.41112688","0.4104587","0.410144","0.4099616","0.40962178","0.40955564"],"string":"[\n \"0.51528734\",\n \"0.49188662\",\n \"0.48297343\",\n \"0.4826368\",\n \"0.4826368\",\n \"0.48228797\",\n \"0.4819829\",\n \"0.47996086\",\n \"0.4773806\",\n \"0.4751501\",\n \"0.47396463\",\n \"0.4729209\",\n \"0.47166255\",\n \"0.4694356\",\n \"0.46928954\",\n \"0.46187517\",\n \"0.46133664\",\n \"0.46113682\",\n \"0.4605297\",\n \"0.46039793\",\n \"0.45815492\",\n \"0.45652682\",\n \"0.45518842\",\n \"0.45386362\",\n \"0.45335993\",\n \"0.45185843\",\n \"0.4492622\",\n \"0.44671535\",\n \"0.44671535\",\n \"0.44569376\",\n \"0.44402635\",\n \"0.44343877\",\n \"0.44273782\",\n \"0.44248655\",\n \"0.4418796\",\n \"0.44075567\",\n \"0.44056225\",\n \"0.43920624\",\n \"0.43920624\",\n \"0.43915415\",\n \"0.43843538\",\n \"0.43835598\",\n \"0.43826148\",\n \"0.43776152\",\n \"0.43738687\",\n \"0.43676823\",\n \"0.43672884\",\n \"0.43546328\",\n \"0.43410403\",\n \"0.4331933\",\n \"0.43213588\",\n \"0.43109053\",\n \"0.43105468\",\n \"0.43046385\",\n \"0.4297891\",\n \"0.42975804\",\n \"0.42814678\",\n \"0.42775372\",\n \"0.42759514\",\n \"0.42717448\",\n \"0.42632934\",\n \"0.42616928\",\n \"0.42323282\",\n \"0.423\",\n \"0.4226542\",\n \"0.42190614\",\n \"0.42026317\",\n \"0.41945434\",\n \"0.41900796\",\n \"0.41886762\",\n \"0.41818112\",\n \"0.4180672\",\n \"0.41786185\",\n \"0.41759932\",\n \"0.4174688\",\n \"0.4173559\",\n \"0.41734484\",\n \"0.41626653\",\n \"0.41616225\",\n \"0.4158853\",\n \"0.415136\",\n \"0.41454726\",\n \"0.41451663\",\n \"0.41385615\",\n \"0.41382977\",\n \"0.41366988\",\n \"0.41355997\",\n \"0.4134131\",\n \"0.41304764\",\n \"0.41244233\",\n \"0.41239828\",\n \"0.41235584\",\n \"0.41217807\",\n \"0.41153744\",\n \"0.4113573\",\n \"0.41112688\",\n \"0.4104587\",\n \"0.410144\",\n \"0.4099616\",\n \"0.40962178\",\n \"0.40955564\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24572,"cells":{"query":{"kind":"string","value":"Sets the check_revocation of this TypesConsoleCertificateSettings."},"document":{"kind":"string","value":"def check_revocation(self, check_revocation):\n\n self._check_revocation = check_revocation"},"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 set_compatibility_check(check_status):\r\n if Config.loaded:\r\n raise Exception(\"compatibility_check must be set before before \" \\\r\n \"using any other functionalities in libclang.\")\r\n\r\n Config.compatibility_check = check_status","def svn_client_revprop_set(char_propname, svn_string_t_propval, char_URL, svn_opt_revision_t_revision, svn_revnum_t_set_rev, svn_boolean_t_force, svn_client_ctx_t_ctx, apr_pool_t_pool): # real signature unknown; restored from __doc__\n pass","def svn_client_revprop_set2(char_propname, svn_string_t_propval, svn_string_t_original_propval, char_URL, svn_opt_revision_t_revision, svn_revnum_t_set_rev, svn_boolean_t_force, svn_client_ctx_t_ctx, apr_pool_t_pool): # real signature unknown; restored from __doc__\n pass","def with_manual_check_always(self):\n self.__manual_check = constants.ALWAYS\n return self","def _set_enable_peer_as_check(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name=\"enable-peer-as-check\", rest_name=\"enable-peer-as-check\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'info': u'Disable routes advertise between peers in same AS', u'cli-full-command': None}}, namespace='urn:brocade.com:mgmt:brocade-bgp', defining_module='brocade-bgp', yang_type='empty', is_config=True)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"enable_peer_as_check must be of a type compatible with empty\"\"\",\n 'defined-type': \"empty\",\n 'generated-type': \"\"\"YANGDynClass(base=YANGBool, is_leaf=True, yang_name=\"enable-peer-as-check\", rest_name=\"enable-peer-as-check\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'info': u'Disable routes advertise between peers in same AS', u'cli-full-command': None}}, namespace='urn:brocade.com:mgmt:brocade-bgp', defining_module='brocade-bgp', yang_type='empty', is_config=True)\"\"\",\n })\n\n self.__enable_peer_as_check = t\n if hasattr(self, '_set'):\n self._set()","def setOverrideCertificateErrors(self, override: bool) -> Awaitable[Dict]:\n return self.client.send(\n \"Security.setOverrideCertificateErrors\", {\"override\": override}\n )","def verify_server_certificate(self, verify_server_certificate):\n\n self._verify_server_certificate = verify_server_certificate","def on_resume_toggled(self, _):\n if not self.resume.get_active():\n self._previous_force_recheck = self.force_recheck.get_active()\n self.force_recheck.set_sensitive(False)\n self.force_recheck.set_active(True)\n else:\n self.force_recheck.set_active(self._previous_force_recheck)\n self.force_recheck.set_sensitive(True)","def use_skip_ssl_verify(self, val=True, force=False):\n if val:\n self.ssl_verify = False\n else:\n self.ssl_verify = True\n\n if force:\n self.force_skip_ssl_verify = True\n else:\n self.force_skip_ssl_verify = False\n\n return val","def with_manual_check_fallback(self):\n self.__manual_check = constants.FALLBACK\n return self","def set_chksum(self, doc, chksum):\n doc.ext_document_references[-1].check_sum = checksum_from_sha1(\n chksum)","def rule_pay_roll_run_approval(self, rule_pay_roll_run_approval):\n allowed_values = [\"Automatic\", \"Manual\"] # noqa: E501\n if self.local_vars_configuration.client_side_validation and rule_pay_roll_run_approval not in allowed_values: # noqa: E501\n raise ValueError(\n \"Invalid value for `rule_pay_roll_run_approval` ({0}), must be one of {1}\" # noqa: E501\n .format(rule_pay_roll_run_approval, allowed_values)\n )\n\n self._rule_pay_roll_run_approval = rule_pay_roll_run_approval","def set_cropping(self, crop=True):\n self._crop = crop\n self._final = None # Force rebuild","def revoke_from_menu(self):\n\n csha1_vhlist = self._get_installed_locations()\n certs = self._populate_saved_certs(csha1_vhlist)\n\n while True:\n if certs:\n code, selection = revocation.display_certs(certs)\n\n if code == display_util.OK:\n revoked_certs = self._safe_revoke([certs[selection]])\n # Since we are currently only revoking one cert at a time...\n if revoked_certs:\n del certs[selection]\n elif code == display_util.HELP:\n revocation.more_info_cert(certs[selection])\n else:\n return\n else:\n logger.info(\n \"There are not any trusted Let's Encrypt \"\n \"certificates for this server.\")\n return","def auto_renew(self, auto_renew):\n\n self._auto_renew = auto_renew","def _set_lsp_config_type_bypass(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name=\"lsp-config-type-bypass\", rest_name=\"lsp-config-type-bypass\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='boolean', is_config=True)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"lsp_config_type_bypass must be of a type compatible with boolean\"\"\",\n 'defined-type': \"boolean\",\n 'generated-type': \"\"\"YANGDynClass(base=YANGBool, is_leaf=True, yang_name=\"lsp-config-type-bypass\", rest_name=\"lsp-config-type-bypass\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='boolean', is_config=True)\"\"\",\n })\n\n self.__lsp_config_type_bypass = t\n if hasattr(self, '_set'):\n self._set()","def set_check_paths(self):\n\n if self.path_listbox.size() > 0:\n self.root.docs_paths = [self.path_listbox.get(idx) for idx in range(self.path_listbox.size())]\n else:\n self.root.docs_paths = []","def __init__(__self__, *,\n autodefined_reverse_flag: pulumi.Input['ResolverConfigAutodefinedReverseFlag'],\n resource_id: pulumi.Input[str]):\n pulumi.set(__self__, \"autodefined_reverse_flag\", autodefined_reverse_flag)\n pulumi.set(__self__, \"resource_id\", resource_id)","def checklists(self, checklists):\n\n self._checklists = checklists","def rotor_setting(self, rotor_setting):\n rotor_setting = self.valid_ring_character(rotor_setting)\n self._rot_offset = self._charset.index(rotor_setting)","def _set_lsp_config_number_of_retries_configured(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name=\"lsp-config-number-of-retries-configured\", rest_name=\"lsp-config-number-of-retries-configured\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='boolean', is_config=True)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"lsp_config_number_of_retries_configured must be of a type compatible with boolean\"\"\",\n 'defined-type': \"boolean\",\n 'generated-type': \"\"\"YANGDynClass(base=YANGBool, is_leaf=True, yang_name=\"lsp-config-number-of-retries-configured\", rest_name=\"lsp-config-number-of-retries-configured\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='boolean', is_config=True)\"\"\",\n })\n\n self.__lsp_config_number_of_retries_configured = t\n if hasattr(self, '_set'):\n self._set()","def set_only_check_type(self, only_check_type=0):\r\n return self._arm.set_only_check_type(only_check_type)","def with_manual_check_never(self):\n self.__manual_check = constants.NEVER\n return self","def set_checklists_status(auth, args):\n global checklists_on\n\n if auth['checklists'] == \"true\":\n checklists_on = True\n else:\n checklists_on = False\n\n # reverse the config setting if specified by the CLI option\n# if args['--checklists']:\n# checklists_on = not checklists_on\n\n return","def SetCanVeto(self, can_veto):\r\n\r\n self.canveto_flag = can_veto","def published_committee_reference_parity_check(self, published_committee_reference_parity_check):\n\n self._published_committee_reference_parity_check = published_committee_reference_parity_check","def __setAutoSpellChecking(self):\n enabled = self.autoSpellCheckAct.isChecked()\n Preferences.setEditor(\"AutoSpellCheckingEnabled\", enabled)\n for editor in self.editors:\n editor.setAutoSpellChecking()","def setConsistencyChecks(self, *args):\n return _libsbml.SBMLDocument_setConsistencyChecks(self, *args)","def load_trust_anchors(self):\n\n utils.write_to_stdout(f\"{datetime.now()}: Loading RPKI Validator\\n\",\n logging.root.level)\n time.sleep(60)\n while self._get_validation_status() is False:\n time.sleep(10)\n utils.write_to_stdout(\".\", logging.root.level)\n utils.write_to_stdout(\"\\n\", logging.root.level)\n self._wait(30, \"Waiting for upload to bgp preview\")","def edit_config_verify(self,\n raw_response: Any,\n *args,\n **kwargs) -> bool:\n pass","def checksum(self, check: bool):\r\n self._checksum = check\r\n self.checksum_hist.append(check)","def can_verify(self, can_verify):\n\n self._can_verify = can_verify","def setRevertable(self, b):\n\n self.revertable = b","def setConsistencyChecksForConversion(self, *args):\n return _libsbml.SBMLDocument_setConsistencyChecksForConversion(self, *args)","def org_apache_felix_https_clientcertificate(self, org_apache_felix_https_clientcertificate: ConfigNodePropertyDropDown):\n\n self._org_apache_felix_https_clientcertificate = org_apache_felix_https_clientcertificate","def syncheck(self, syncheck) :\n\t\ttry :\n\t\t\tself._syncheck = syncheck\n\t\texcept Exception as e:\n\t\t\traise e","def update_checker_setting(self, project_name, checker_name, enabled):\n request_parms = {}\n request_parms[\"action\"] = \"update_defect_type\"\n request_parms[\"project\"] = project_name\n request_parms[\"code\"] = checker_name\n request_parms[\"enabled\"] = enabled\n return self.send_request(request_parms)","def SetTrusted(self, trusted):\n self.__trusted = trusted","def setTrustProxy(self, trustProxy):\n pass","def set_checked_ts(self, checked_ts):\n self._checked_ts = checked_ts","def __init__(__self__, *,\n renewal_settings: Optional[pulumi.Input['GoogleCloudChannelV1RenewalSettingsArgs']] = None):\n if renewal_settings is not None:\n pulumi.set(__self__, \"renewal_settings\", renewal_settings)","def set_lanzar(self):\n self.lanzar = True","def set_right_ascension(self, target_right_ascension):\n self.right_ascension = target_right_ascension\n return self.right_ascension","def click_guarantee_cli_checkbox(self):\n self.click_element(self.guarantee_cli_checkbox_locator)","def trusted(self, trusted):\n\n self._trusted = trusted","def autodefined_reverse_flag(self) -> pulumi.Output['ResolverConfigAutodefinedReverseFlag']:\n return pulumi.get(self, \"autodefined_reverse_flag\")","def set_reverse(rev):\n global is_reverse\n is_reverse = rev","def rebalance_policy(self, rebalance_policy):\n allowed_values = [\"auto\", \"manual\"]\n if rebalance_policy is not None and rebalance_policy not in allowed_values:\n raise ValueError(\n \"Invalid value for `rebalance_policy`, must be one of {0}\"\n .format(allowed_values)\n )\n\n self._rebalance_policy = rebalance_policy","def svn_fs_change_rev_prop(*args):\r\n return _fs.svn_fs_change_rev_prop(*args)","def autodefined_reverse_flag(self) -> pulumi.Input['ResolverConfigAutodefinedReverseFlag']:\n return pulumi.get(self, \"autodefined_reverse_flag\")","def org_apache_felix_https_jetty_renegotiate_allowed(self, org_apache_felix_https_jetty_renegotiate_allowed: ConfigNodePropertyBoolean):\n\n self._org_apache_felix_https_jetty_renegotiate_allowed = org_apache_felix_https_jetty_renegotiate_allowed","def test_revoked_cert(self):\n\n # Initially should be able to to operations like open a session\n self._open_session()\n HttpAgentRpc().remove_host(self.host.fqdn)\n\n # After revokation any access should be bounced\n response = self._post([])\n self.assertEqual(response.status_code, 403)\n response = self._get()\n self.assertEqual(response.status_code, 403)","def command_preflight_check(self):\n checks_pass, failures = self.environment.perform_preflight_check()\n if checks_pass:\n print('All checks pass.')\n else:\n sys.stderr.write('Problems encountered:\\n')\n for msg in failures:\n sys.stderr.write(' - %s\\n' % msg)\n sys.exit(1)","def _set_lsp_frr_computation_mode_use_bypass_liberal(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name=\"lsp-frr-computation-mode-use-bypass-liberal\", rest_name=\"lsp-frr-computation-mode-use-bypass-liberal\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='boolean', is_config=True)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"lsp_frr_computation_mode_use_bypass_liberal must be of a type compatible with boolean\"\"\",\n 'defined-type': \"boolean\",\n 'generated-type': \"\"\"YANGDynClass(base=YANGBool, is_leaf=True, yang_name=\"lsp-frr-computation-mode-use-bypass-liberal\", rest_name=\"lsp-frr-computation-mode-use-bypass-liberal\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='boolean', is_config=True)\"\"\",\n })\n\n self.__lsp_frr_computation_mode_use_bypass_liberal = t\n if hasattr(self, '_set'):\n self._set()","def set_remit_to_address(self, remit_to_address):\n self.remit_to_address = remit_to_address","def auto_resume_at_loser(self, auto_resume_at_loser):\n\n self._auto_resume_at_loser = auto_resume_at_loser","def fill_disable_ssl_verification(self, data):\n disable_ssl_verification = get_optional_value(data, self.DISABLE_SSL, False)\n self.verify_ssl = not bool(disable_ssl_verification)","def _set_lsp_config_frr_configured(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name=\"lsp-config-frr-configured\", rest_name=\"lsp-config-frr-configured\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='boolean', is_config=True)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"lsp_config_frr_configured must be of a type compatible with boolean\"\"\",\n 'defined-type': \"boolean\",\n 'generated-type': \"\"\"YANGDynClass(base=YANGBool, is_leaf=True, yang_name=\"lsp-config-frr-configured\", rest_name=\"lsp-config-frr-configured\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='boolean', is_config=True)\"\"\",\n })\n\n self.__lsp_config_frr_configured = t\n if hasattr(self, '_set'):\n self._set()","def setViewerPreferences(self,viewerPreferences):\n self.PDFreactorConfiguration.in1[\"viewerPreferences\"] = viewerPreferences","def client_cert(self, client_cert):\n\n self._client_cert = client_cert","def setRefDelay (self, ra, dec):\n self._response.setRefDelay(ra, dec)","def ocsp_revoked(self, cert_path, chain_path):\n if self.broken:\n return False\n\n\n url, host = self.determine_ocsp_server(cert_path)\n if not host:\n return False\n # jdkasten thanks \"Bulletproof SSL and TLS - Ivan Ristic\" for documenting this!\n cmd = [\"openssl\", \"ocsp\",\n \"-no_nonce\",\n \"-issuer\", chain_path,\n \"-cert\", cert_path,\n \"-url\", url,\n \"-CAfile\", chain_path,\n \"-verify_other\", chain_path,\n \"-trust_other\",\n \"-header\"] + self.host_args(host)\n logger.debug(\"Querying OCSP for %s\", cert_path)\n logger.debug(\" \".join(cmd))\n try:\n output, err = util.run_script(cmd, log=logger.debug)\n except errors.SubprocessError:\n logger.info(\"OCSP check failed for %s (are we offline?)\", cert_path)\n return False\n\n return _translate_ocsp_query(cert_path, output, err)","def __check_opts(self):\n self.ca_cert_file = os.environ['HOME'] + '/.cat_installer/ca.pem'\n self.pfx_file = os.environ['HOME'] + '/.cat_installer/user.p12'\n if not os.path.isfile(self.ca_cert_file):\n print(Messages.cert_error)\n sys.exit(2)","def create_verification_overriding_cfg(self, resource_type=None,\n resource_ref=None,\n resource_action=None,\n impersonation_allowed=False):\n imp_allowed = impersonation_allowed\n if impersonation_allowed is None:\n imp_allowed = False\n\n resp = self.create_verification(\n resource_type=resource_type or self.config.resource_type,\n resource_ref=resource_ref or self.config.resource_ref,\n resource_action=resource_action or self.config.resource_action,\n impersonation_allowed=imp_allowed)\n\n return resp","def set_in_check(self, state):\n\n self._in_check = state","def verify_crl(cert, path, validation_context, use_deltas=True, cert_description=None, end_entity_name_override=None):\n\n if not isinstance(cert, x509.Certificate):\n raise TypeError(pretty_message(\n '''\n cert must be an instance of asn1crypto.x509.Certificate, not %s\n ''',\n type_name(cert)\n ))\n\n if not isinstance(path, ValidationPath):\n raise TypeError(pretty_message(\n '''\n path must be an instance of certvalidator.path.ValidationPath,\n not %s\n ''',\n type_name(path)\n ))\n\n if not isinstance(validation_context, ValidationContext):\n raise TypeError(pretty_message(\n '''\n validation_context must be an instance of\n certvalidator.context.ValidationContext, not %s\n ''',\n type_name(validation_context)\n ))\n\n if cert_description is None:\n cert_description = 'the certificate'\n\n if not isinstance(cert_description, str_cls):\n raise TypeError(pretty_message(\n '''\n cert_description must be a unicode string, not %s\n ''',\n type_name(cert_description)\n ))\n\n moment = validation_context.moment\n certificate_registry = validation_context.certificate_registry\n\n certificate_lists = validation_context.retrieve_crls(cert)\n\n cert_issuer = path.find_issuer(cert)\n\n complete_lists_by_issuer = {}\n delta_lists_by_issuer = {}\n for certificate_list in certificate_lists:\n issuer_hashable = certificate_list.issuer.hashable\n if certificate_list.delta_crl_indicator_value is None:\n if issuer_hashable not in complete_lists_by_issuer:\n complete_lists_by_issuer[issuer_hashable] = []\n complete_lists_by_issuer[issuer_hashable].append(certificate_list)\n else:\n if issuer_hashable not in delta_lists_by_issuer:\n delta_lists_by_issuer[issuer_hashable] = []\n delta_lists_by_issuer[issuer_hashable].append(certificate_list)\n\n # In the main loop, only complete CRLs are processed, so delta CRLs are\n # weeded out of the todo list\n crls_to_process = []\n for issuer_crls in complete_lists_by_issuer.values():\n crls_to_process.extend(issuer_crls)\n total_crls = len(crls_to_process)\n\n # Build a lookup table for the Distribution point objects associated with\n # an issuer name hashable\n distribution_point_map = {}\n sources = [cert.crl_distribution_points]\n if use_deltas:\n sources.extend(cert.delta_crl_distribution_points)\n for dp_list in sources:\n for distribution_point in dp_list:\n if isinstance(distribution_point['crl_issuer'], x509.GeneralNames):\n dp_name_hashes = []\n for general_name in distribution_point['crl_issuer']:\n if general_name.name == 'directory_name':\n dp_name_hashes.append(general_name.chosen.hashable)\n else:\n dp_name_hashes = [cert.issuer.hashable]\n for dp_name_hash in dp_name_hashes:\n if dp_name_hash not in distribution_point_map:\n distribution_point_map[dp_name_hash] = []\n distribution_point_map[dp_name_hash].append(distribution_point)\n\n valid_reasons = set([\n 'key_compromise',\n 'ca_compromise',\n 'affiliation_changed',\n 'superseded',\n 'cessation_of_operation',\n 'certificate_hold',\n 'privilege_withdrawn',\n 'aa_compromise',\n ])\n\n known_extensions = set([\n 'issuer_alt_name',\n 'crl_number',\n 'delta_crl_indicator',\n 'issuing_distribution_point',\n 'authority_key_identifier',\n 'freshest_crl',\n 'authority_information_access',\n ])\n\n checked_reasons = set()\n\n failures = []\n issuer_failures = 0\n\n while len(crls_to_process) > 0:\n certificate_list = crls_to_process.pop(0)\n crl_idp = certificate_list.issuing_distribution_point_value\n delta_certificate_list = None\n delta_crl_idp = None\n\n interim_reasons = set()\n\n crl_issuer = None\n crl_issuer_name = None\n is_indirect = False\n\n if crl_idp and crl_idp['indirect_crl'].native:\n is_indirect = True\n crl_idp_name = crl_idp['distribution_point']\n if crl_idp_name:\n if crl_idp_name.name == 'full_name':\n crl_issuer_name = crl_idp_name.chosen[0].chosen\n else:\n crl_issuer_name = cert_issuer.subject.copy().chosen.append(\n crl_idp_name.chosen\n )\n elif certificate_list.authority_key_identifier:\n tmp_crl_issuer = certificate_registry.retrieve_by_key_identifier(\n certificate_list.authority_key_identifier\n )\n crl_issuer_name = tmp_crl_issuer.subject\n else:\n failures.append((\n 'CRL is marked as an indirect CRL, but provides no '\n 'mechanism for locating the CRL issuer certificate',\n certificate_list\n ))\n continue\n else:\n crl_issuer_name = certificate_list.issuer\n\n if not crl_issuer:\n crl_issuer = validation_context.check_crl_issuer(certificate_list)\n\n if not crl_issuer:\n candidate_crl_issuers = certificate_registry.retrieve_by_name(crl_issuer_name, cert_issuer)\n candidates_skipped = 0\n signatures_failed = 0\n unauthorized_certs = 0\n\n if not candidate_crl_issuers and crl_issuer_name != certificate_list.issuer:\n candidate_crl_issuers = certificate_registry.retrieve_by_name(certificate_list.issuer, cert_issuer)\n\n for candidate_crl_issuer in candidate_crl_issuers:\n direct_issuer = candidate_crl_issuer.subject == cert_issuer.subject\n\n # In some cases an indirect CRL issuer is a certificate issued\n # by the certificate issuer. However, we need to ensure that\n # the candidate CRL issuer is not the certificate being checked,\n # otherwise we may be checking an incorrect CRL and produce\n # incorrect results.\n indirect_issuer = candidate_crl_issuer.issuer == cert_issuer.subject\n indirect_issuer = indirect_issuer and candidate_crl_issuer.sha256 != cert.sha256\n\n if not direct_issuer and not indirect_issuer and not is_indirect:\n candidates_skipped += 1\n continue\n\n # Step f\n candidate_crl_issuer_path = None\n\n if validation_context:\n candidate_crl_issuer_path = validation_context.check_validation(candidate_crl_issuer)\n\n if candidate_crl_issuer_path is None:\n candidate_crl_issuer_path = path.copy().truncate_to_issuer(candidate_crl_issuer)\n candidate_crl_issuer_path.append(candidate_crl_issuer)\n try:\n # Pre-emptively mark a path as validated to prevent recursion\n if validation_context:\n validation_context.record_validation(candidate_crl_issuer, candidate_crl_issuer_path)\n\n temp_override = end_entity_name_override\n if temp_override is None and candidate_crl_issuer.sha256 != cert_issuer.sha256:\n temp_override = cert_description + ' CRL issuer'\n _validate_path(\n validation_context,\n candidate_crl_issuer_path,\n end_entity_name_override=temp_override\n )\n\n except (PathValidationError) as e:\n # If the validation did not work out, clear it\n if validation_context:\n validation_context.clear_validation(candidate_crl_issuer)\n\n # We let a revoked error fall through since step k will catch\n # it with a correct error message\n if isinstance(e, RevokedError):\n raise\n raise CRLValidationError('CRL issuer certificate path could not be validated')\n\n key_usage_value = candidate_crl_issuer.key_usage_value\n if key_usage_value and 'crl_sign' not in key_usage_value.native:\n unauthorized_certs += 1\n continue\n\n try:\n # Step g\n _verify_signature(certificate_list, candidate_crl_issuer)\n\n crl_issuer = candidate_crl_issuer\n break\n\n except (CRLValidationError):\n signatures_failed += 1\n continue\n\n if crl_issuer is None:\n if candidates_skipped == len(candidate_crl_issuers):\n issuer_failures += 1\n else:\n if signatures_failed == len(candidate_crl_issuers):\n failures.append((\n 'CRL signature could not be verified',\n certificate_list\n ))\n elif unauthorized_certs == len(candidate_crl_issuers):\n failures.append((\n 'The CRL issuer is not authorized to sign CRLs',\n certificate_list\n ))\n else:\n failures.append((\n 'Unable to locate CRL issuer certificate',\n certificate_list\n ))\n continue\n else:\n validation_context.record_crl_issuer(certificate_list, crl_issuer)\n\n # Step b 1\n has_dp_crl_issuer = False\n dp_match = False\n\n dps = cert.crl_distribution_points_value\n if dps:\n crl_issuer_general_name = x509.GeneralName(\n name='directory_name',\n value=crl_issuer.subject\n )\n for dp in dps:\n if dp['crl_issuer']:\n has_dp_crl_issuer = True\n if crl_issuer_general_name in dp['crl_issuer']:\n dp_match = True\n\n same_issuer = crl_issuer.subject == cert_issuer.subject\n indirect_match = has_dp_crl_issuer and dp_match and is_indirect\n missing_idp = has_dp_crl_issuer and (not dp_match or not is_indirect)\n indirect_crl_issuer = crl_issuer.issuer == cert_issuer.subject\n\n if (not same_issuer and not indirect_match and not indirect_crl_issuer) or missing_idp:\n issuer_failures += 1\n continue\n\n # Check to make sure the CRL is valid for the moment specified\n if moment < certificate_list['tbs_cert_list']['this_update'].native:\n failures.append((\n 'CRL is from after the validation time',\n certificate_list\n ))\n continue\n if moment > certificate_list['tbs_cert_list']['next_update'].native:\n failures.append((\n 'CRL should have been regenerated by the validation time',\n certificate_list\n ))\n continue\n\n # Step b 2\n\n if crl_idp is not None:\n # Step b 2 i\n has_idp_name = False\n has_dp_name = False\n idp_dp_match = False\n\n idp_general_names = []\n idp_dp_name = crl_idp['distribution_point']\n if idp_dp_name:\n has_idp_name = True\n if idp_dp_name.name == 'full_name':\n for general_name in idp_dp_name.chosen:\n idp_general_names.append(general_name)\n else:\n inner_extended_issuer_name = crl_issuer.subject.copy()\n inner_extended_issuer_name.chosen.append(idp_dp_name.chosen.untag())\n idp_general_names.append(x509.GeneralName(\n name='directory_name',\n value=inner_extended_issuer_name\n ))\n\n dps = cert.crl_distribution_points_value\n if dps:\n for dp in dps:\n if idp_dp_match:\n break\n dp_name = dp['distribution_point']\n if dp_name:\n has_dp_name = True\n if dp_name.name == 'full_name':\n for general_name in dp_name.chosen:\n if general_name in idp_general_names:\n idp_dp_match = True\n break\n else:\n inner_extended_issuer_name = crl_issuer.subject.copy()\n inner_extended_issuer_name.chosen.append(dp_name.chosen.untag())\n dp_extended_issuer_name = x509.GeneralName(\n name='directory_name',\n value=inner_extended_issuer_name\n )\n\n if dp_extended_issuer_name in idp_general_names:\n idp_dp_match = True\n\n elif dp['crl_issuer']:\n has_dp_name = True\n for dp_crl_issuer_name in dp['crl_issuer']:\n if dp_crl_issuer_name in idp_general_names:\n idp_dp_match = True\n break\n else:\n # If there is no DP, we consider the CRL issuer name to be it\n has_dp_name = True\n general_name = x509.GeneralName(\n name='directory_name',\n value=crl_issuer_name\n )\n if general_name in idp_general_names:\n idp_dp_match = True\n\n idp_dp_match_failed = has_idp_name and has_dp_name and not idp_dp_match\n\n if idp_dp_match_failed:\n failures.append((\n pretty_message(\n '''\n The CRL issuing distribution point extension does not\n share any names with the certificate CRL distribution\n point extension\n '''\n ),\n certificate_list\n ))\n issuer_failures += 1\n continue\n\n # Step b 2 ii\n if crl_idp['only_contains_user_certs'].native:\n if cert.basic_constraints_value and cert.basic_constraints_value['ca'].native:\n failures.append((\n pretty_message(\n '''\n CRL only contains end-entity certificates and\n certificate is a CA certificate\n '''\n ),\n certificate_list\n ))\n continue\n\n # Step b 2 iii\n if crl_idp['only_contains_ca_certs'].native:\n if not cert.basic_constraints_value or cert.basic_constraints_value['ca'].native is False:\n failures.append((\n pretty_message(\n '''\n CRL only contains CA certificates and certificate\n is an end-entity certificate\n '''\n ),\n certificate_list\n ))\n continue\n\n # Step b 2 iv\n if crl_idp['only_contains_attribute_certs'].native:\n failures.append((\n 'CRL only contains attribute certificates',\n certificate_list\n ))\n continue\n\n # Step c\n if use_deltas and certificate_list.freshest_crl_value and len(certificate_list.freshest_crl_value) > 0:\n for candidate_delta_cl in delta_lists_by_issuer.get(crl_issuer_name.hashable, []):\n\n # Step c 1\n if candidate_delta_cl.issuer != crl_issuer_name:\n continue\n\n # Step c 2\n delta_crl_idp = candidate_delta_cl.issuing_distribution_point_value\n if (crl_idp is None and delta_crl_idp is not None) or (crl_idp is not None and delta_crl_idp is None):\n continue\n\n if crl_idp and crl_idp.native != delta_crl_idp.native:\n continue\n\n # Step c 3\n if certificate_list.authority_key_identifier != candidate_delta_cl.authority_key_identifier:\n continue\n\n delta_certificate_list = candidate_delta_cl\n break\n\n # Step d\n idp_reasons = None\n\n if crl_idp and crl_idp['only_some_reasons'].native is not None:\n idp_reasons = crl_idp['only_some_reasons'].native\n\n reason_keys = None\n if idp_reasons:\n reason_keys = idp_reasons\n\n if reason_keys is None:\n interim_reasons = valid_reasons.copy()\n else:\n interim_reasons = reason_keys\n\n # Step e\n # We don't skip a CRL if it only contains reasons already checked since\n # a certificate issuer can self-issue a new cert that is used for CRLs\n\n if certificate_list.critical_extensions - known_extensions:\n failures.append((\n 'One or more unrecognized critical extensions are present in '\n 'the CRL',\n certificate_list\n ))\n continue\n\n if use_deltas and delta_certificate_list and delta_certificate_list.critical_extensions - known_extensions:\n failures.append((\n 'One or more unrecognized critical extensions are present in '\n 'the delta CRL',\n delta_certificate_list\n ))\n continue\n\n # Step h\n if use_deltas and delta_certificate_list:\n try:\n _verify_signature(delta_certificate_list, crl_issuer)\n except (CRLValidationError):\n failures.append((\n 'Delta CRL signature could not be verified',\n certificate_list,\n delta_certificate_list\n ))\n continue\n\n if moment < delta_certificate_list['tbs_cert_list']['this_update'].native:\n failures.append((\n 'Delta CRL is from after the validation time',\n certificate_list,\n delta_certificate_list\n ))\n continue\n if moment > delta_certificate_list['tbs_cert_list']['next_update'].native:\n failures.append((\n 'Delta CRL is from before the validation time',\n certificate_list,\n delta_certificate_list\n ))\n continue\n\n # Step i\n revoked_reason = None\n revoked_date = None\n\n if use_deltas and delta_certificate_list:\n try:\n revoked_date, revoked_reason = _find_cert_in_list(cert, cert_issuer, delta_certificate_list, crl_issuer)\n except (NotImplementedError):\n failures.append((\n 'One or more critical extensions are present in the CRL '\n 'entry for the certificate',\n delta_certificate_list\n ))\n continue\n\n # Step j\n if revoked_reason is None:\n try:\n revoked_date, revoked_reason = _find_cert_in_list(cert, cert_issuer, certificate_list, crl_issuer)\n except (NotImplementedError):\n failures.append((\n 'One or more critical extensions are present in the CRL '\n 'entry for the certificate',\n certificate_list\n ))\n continue\n\n # Step k\n if revoked_reason and revoked_reason.native == 'remove_from_crl':\n revoked_reason = None\n revoked_date = None\n\n if revoked_reason:\n reason = revoked_reason.human_friendly\n date = revoked_date.native.strftime('%Y-%m-%d')\n time = revoked_date.native.strftime('%H:%M:%S')\n raise RevokedError(pretty_message(\n '''\n CRL indicates %s was revoked at %s on %s, due to %s\n ''',\n cert_description,\n time,\n date,\n reason\n ))\n\n # Step l\n checked_reasons |= interim_reasons\n\n # CRLs should not include this value, but at least one of the examples\n # from the NIST test suite does\n checked_reasons -= set(['unused'])\n\n if checked_reasons != valid_reasons:\n if total_crls == issuer_failures:\n raise CRLNoMatchesError(pretty_message(\n '''\n No CRLs were issued by the issuer of %s, or any indirect CRL\n issuer\n ''',\n cert_description\n ))\n\n if not failures:\n failures.append((\n 'The available CRLs do not cover all revocation reasons',\n ))\n\n raise CRLValidationIndeterminateError(\n pretty_message(\n '''\n Unable to determine if %s is revoked due to insufficient\n information from known CRLs\n ''',\n cert_description\n ),\n failures\n )","def set_checked(self, checked):\n self._checked = checked","def on_reencryptCheckBox_toggled(self, on):\n self.__updateUI()","def setCleanupTool(self,value):\n self.PDFreactorConfiguration.in1[\"cleanupTool\"] = value","def __init__(self, check_revocation=None, console_ca_cert=None, console_custom_cert=None, hpkp=None, local_vars_configuration=None): # noqa: E501 # noqa: E501\n if local_vars_configuration is None:\n local_vars_configuration = Configuration.get_default_copy()\n self.local_vars_configuration = local_vars_configuration\n\n self._check_revocation = None\n self._console_ca_cert = None\n self._console_custom_cert = None\n self._hpkp = None\n self.discriminator = None\n\n if check_revocation is not None:\n self.check_revocation = check_revocation\n if console_ca_cert is not None:\n self.console_ca_cert = console_ca_cert\n if console_custom_cert is not None:\n self.console_custom_cert = console_custom_cert\n if hpkp is not None:\n self.hpkp = hpkp","def test_rotate_certificates(self):\n self.x509.generate_multiple_x509_certs(servers=self.servers)\n self.log.info(\"Manifest before rotating certs #########\\n {0}\".\n format(json.dumps(self.x509.manifest, indent=4)))\n for server in self.servers[:self.nodes_init]:\n _ = self.x509.upload_root_certs(server)\n self.x509.upload_node_certs(servers=self.servers[:self.nodes_init])\n self.x509.delete_unused_out_of_the_box_CAs(server=self.master)\n self.x509.upload_client_cert_settings(server=self.servers[0])\n self.log.info(\"Checking authentication ...\")\n self.auth(servers=self.servers[:self.nodes_init])\n self.x509.rotate_certs(self.servers, \"all\")\n self.log.info(\"Manifest after rotating certs #########\\n {0}\".\n format(json.dumps(self.x509.manifest, indent=4)))\n\n https_val = CbServer.use_https # so that add_node uses https\n CbServer.use_https = True\n task = self.cluster.async_rebalance(self.servers[:self.nodes_init],\n self.servers[self.nodes_init:], [])\n self.wait_for_rebalance_to_complete(task)\n CbServer.use_https = https_val\n self.log.info(\"Checking authentication ...\")\n self.auth(servers=self.servers)\n content = self.x509.get_trusted_CAs()\n self.log.info(\"Trusted CAs: {0}\".format(content))\n self.log.info(\"Active Root CAs names {0}\".format(self.x509.root_ca_names))","def set(self, boolean):\n self._val = boolean","def console_ca_cert(self, console_ca_cert):\n\n self._console_ca_cert = console_ca_cert","def test_set_verify_callback_reference(self):\n\n def callback(conn, cert, errnum, depth, ok): # pragma: no cover\n return ok\n\n tracker = ref(callback)\n\n context = Context(SSLv23_METHOD)\n context.set_verify(VERIFY_PEER, callback)\n del callback\n\n conn = Connection(context, None)\n context.set_verify(VERIFY_NONE)\n\n collect()\n collect()\n assert tracker()\n\n conn.set_verify(VERIFY_PEER, lambda conn, cert, errnum, depth, ok: ok)\n collect()\n collect()\n callback = tracker()\n if callback is not None: # pragma: nocover\n referrers = get_referrers(callback)\n if len(referrers) > 1:\n pytest.fail(\"Some references remain: %r\" % (referrers,))","def verified(self, verified):\n\n self._verified = verified","def cert(self, value):\n self._cert = value","def server_auth_crl_ids(self, server_auth_crl_ids):\n\n self._server_auth_crl_ids = server_auth_crl_ids","def test_is_revoked_target(self):\n self.site.mode = SITE_MODE_SOURCE\n self.site.save()\n self.assertEqual(self.project.is_revoked(), False)\n self.remote_project.level = SODAR_CONSTANTS['REMOTE_LEVEL_REVOKED']\n self.remote_project.save()\n self.assertEqual(self.project.is_revoked(), True)","def set_check_interval (self, interval):\n\t\tif self.__timeout:\n\t\t\tgobject.source_remove(self.__timeout)\n\t\tself.__timeout = gobject.timeout_add(interval * 60000, \n\t\t\tself.run_mailcheck)","def trusted_server_certificates(self, trusted_server_certificates):\n if trusted_server_certificates is not None and len(trusted_server_certificates) > 100000:\n raise ValueError(\"Invalid value for `trusted_server_certificates`, length must be less than or equal to `100000`\")\n if trusted_server_certificates is not None and len(trusted_server_certificates) < 0:\n raise ValueError(\"Invalid value for `trusted_server_certificates`, length must be greater than or equal to `0`\")\n\n self._trusted_server_certificates = trusted_server_certificates","def __init__(__self__, *,\n cross_subscription_restore_settings: Optional['outputs.CrossSubscriptionRestoreSettingsResponse'] = None):\n if cross_subscription_restore_settings is not None:\n pulumi.set(__self__, \"cross_subscription_restore_settings\", cross_subscription_restore_settings)","def set_recharge(self, recharge):\n self.__recharge = recharge","def check(self, verifier = None):\n for (k, v) in self._versions.items():\n #print(k,v)\n if k == 'KLEE':\n # check KLEE only if we are using KLEE\n if verifier.startswith('klee'):\n vers = self._get_klee_version()\n expected = self._decode(v)\n self._check(k, expected, vers)\n elif k == 'sbt-slicer':\n vers = self._get_slicer_version()\n expected = self._decode(v[:8])\n self._check(k, expected, vers)\n elif k == 'sbt-instrumentation':\n vers = self._get_instr_version()\n expected = self._decode(v[:8])\n self._check(k, expected, vers)","def renewable(self, renewable):\n if renewable is None:\n raise ValueError(\"Invalid value for `renewable`, must not be `None`\") # noqa: E501\n\n self._renewable = renewable","def revoke_certificate(self):\n return self.__query(\"certificateRevoke\", kwargs)","def checkin(self, checkin):\n\n self._checkin = checkin","def HasRestoredProp(self, flag):\n\n if flag:\n self._hasRestored = flag","def svn_info_t_rev_set(svn_info_t_self, svn_revnum_t_rev): # real signature unknown; restored from __doc__\n pass","def runoff_election(self, runoff_election):\n\n self._runoff_election = runoff_election","def remittance_reference(self, remittance_reference):\n\n self._remittance_reference = remittance_reference","def y_flag(self):\n if self.calibrationlog:\n self.calibrationlogflag = True\n self.calibrationlogtime = DEFAULT_CALIBRATIONLOG_TIME","def preferred_certificates(self, preferred_certificates):\n\n self._preferred_certificates = preferred_certificates","def _set_lsp_config_number_of_retries(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"lsp-config-number-of-retries\", rest_name=\"lsp-config-number-of-retries\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='uint32', is_config=True)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"lsp_config_number_of_retries must be of a type compatible with uint32\"\"\",\n 'defined-type': \"uint32\",\n 'generated-type': \"\"\"YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\"lsp-config-number-of-retries\", rest_name=\"lsp-config-number-of-retries\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='uint32', is_config=True)\"\"\",\n })\n\n self.__lsp_config_number_of_retries = t\n if hasattr(self, '_set'):\n self._set()","def rotateAfterCheckChanged(self, state):\n if state == QtCore.Qt.Unchecked:\n self.rotateAfter = False\n\n else:\n self.rotateAfter = True","def set_wraperror(self, value: bool = True) -> None:\n self.WRAPERROR = tools.coerce_bool(value)","def set_right_trig(self, trig):\n\t\tself.right_trig = trig","def initialize_options(self):\n self.branch = \"master\"\n self.fix = False\n super(lint, self).initialize_options()","def set_rx_calibrate (self, rx_calibrate):\n\t\tif ((rx_calibrate == 0) or (rx_calibrate == 1)):\n\t\t\tself._rx_calibrate = rx_calibrate\n\t\telse:\n\t\t\tsys.stderr.write(\"\\nERROR : %s rx_calibrate must be 0 (disabled) or 1 (enabled) so it can't be %s !\\n\" % (self._target_id, rx_calibrate))\n\t\t\tsys.exit(1)","def __reference_frame_checkbox(self, c):\n if len(self.__robots) > 0:\n self.__robots[self.__selected_robot].set_reference_visibility(\n c.checked)","def setHandshakeOp(self, handshaker):\r\n try:\r\n self._checkAssert(0)\r\n self.handshaker = handshaker\r\n self._doHandshakeOp()\r\n except:\r\n self._clear()\r\n raise"],"string":"[\n \"def set_compatibility_check(check_status):\\r\\n if Config.loaded:\\r\\n raise Exception(\\\"compatibility_check must be set before before \\\" \\\\\\r\\n \\\"using any other functionalities in libclang.\\\")\\r\\n\\r\\n Config.compatibility_check = check_status\",\n \"def svn_client_revprop_set(char_propname, svn_string_t_propval, char_URL, svn_opt_revision_t_revision, svn_revnum_t_set_rev, svn_boolean_t_force, svn_client_ctx_t_ctx, apr_pool_t_pool): # real signature unknown; restored from __doc__\\n pass\",\n \"def svn_client_revprop_set2(char_propname, svn_string_t_propval, svn_string_t_original_propval, char_URL, svn_opt_revision_t_revision, svn_revnum_t_set_rev, svn_boolean_t_force, svn_client_ctx_t_ctx, apr_pool_t_pool): # real signature unknown; restored from __doc__\\n pass\",\n \"def with_manual_check_always(self):\\n self.__manual_check = constants.ALWAYS\\n return self\",\n \"def _set_enable_peer_as_check(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name=\\\"enable-peer-as-check\\\", rest_name=\\\"enable-peer-as-check\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'info': u'Disable routes advertise between peers in same AS', u'cli-full-command': None}}, namespace='urn:brocade.com:mgmt:brocade-bgp', defining_module='brocade-bgp', yang_type='empty', is_config=True)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"enable_peer_as_check must be of a type compatible with empty\\\"\\\"\\\",\\n 'defined-type': \\\"empty\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=YANGBool, is_leaf=True, yang_name=\\\"enable-peer-as-check\\\", rest_name=\\\"enable-peer-as-check\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'info': u'Disable routes advertise between peers in same AS', u'cli-full-command': None}}, namespace='urn:brocade.com:mgmt:brocade-bgp', defining_module='brocade-bgp', yang_type='empty', is_config=True)\\\"\\\"\\\",\\n })\\n\\n self.__enable_peer_as_check = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def setOverrideCertificateErrors(self, override: bool) -> Awaitable[Dict]:\\n return self.client.send(\\n \\\"Security.setOverrideCertificateErrors\\\", {\\\"override\\\": override}\\n )\",\n \"def verify_server_certificate(self, verify_server_certificate):\\n\\n self._verify_server_certificate = verify_server_certificate\",\n \"def on_resume_toggled(self, _):\\n if not self.resume.get_active():\\n self._previous_force_recheck = self.force_recheck.get_active()\\n self.force_recheck.set_sensitive(False)\\n self.force_recheck.set_active(True)\\n else:\\n self.force_recheck.set_active(self._previous_force_recheck)\\n self.force_recheck.set_sensitive(True)\",\n \"def use_skip_ssl_verify(self, val=True, force=False):\\n if val:\\n self.ssl_verify = False\\n else:\\n self.ssl_verify = True\\n\\n if force:\\n self.force_skip_ssl_verify = True\\n else:\\n self.force_skip_ssl_verify = False\\n\\n return val\",\n \"def with_manual_check_fallback(self):\\n self.__manual_check = constants.FALLBACK\\n return self\",\n \"def set_chksum(self, doc, chksum):\\n doc.ext_document_references[-1].check_sum = checksum_from_sha1(\\n chksum)\",\n \"def rule_pay_roll_run_approval(self, rule_pay_roll_run_approval):\\n allowed_values = [\\\"Automatic\\\", \\\"Manual\\\"] # noqa: E501\\n if self.local_vars_configuration.client_side_validation and rule_pay_roll_run_approval not in allowed_values: # noqa: E501\\n raise ValueError(\\n \\\"Invalid value for `rule_pay_roll_run_approval` ({0}), must be one of {1}\\\" # noqa: E501\\n .format(rule_pay_roll_run_approval, allowed_values)\\n )\\n\\n self._rule_pay_roll_run_approval = rule_pay_roll_run_approval\",\n \"def set_cropping(self, crop=True):\\n self._crop = crop\\n self._final = None # Force rebuild\",\n \"def revoke_from_menu(self):\\n\\n csha1_vhlist = self._get_installed_locations()\\n certs = self._populate_saved_certs(csha1_vhlist)\\n\\n while True:\\n if certs:\\n code, selection = revocation.display_certs(certs)\\n\\n if code == display_util.OK:\\n revoked_certs = self._safe_revoke([certs[selection]])\\n # Since we are currently only revoking one cert at a time...\\n if revoked_certs:\\n del certs[selection]\\n elif code == display_util.HELP:\\n revocation.more_info_cert(certs[selection])\\n else:\\n return\\n else:\\n logger.info(\\n \\\"There are not any trusted Let's Encrypt \\\"\\n \\\"certificates for this server.\\\")\\n return\",\n \"def auto_renew(self, auto_renew):\\n\\n self._auto_renew = auto_renew\",\n \"def _set_lsp_config_type_bypass(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name=\\\"lsp-config-type-bypass\\\", rest_name=\\\"lsp-config-type-bypass\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='boolean', is_config=True)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"lsp_config_type_bypass must be of a type compatible with boolean\\\"\\\"\\\",\\n 'defined-type': \\\"boolean\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=YANGBool, is_leaf=True, yang_name=\\\"lsp-config-type-bypass\\\", rest_name=\\\"lsp-config-type-bypass\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='boolean', is_config=True)\\\"\\\"\\\",\\n })\\n\\n self.__lsp_config_type_bypass = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def set_check_paths(self):\\n\\n if self.path_listbox.size() > 0:\\n self.root.docs_paths = [self.path_listbox.get(idx) for idx in range(self.path_listbox.size())]\\n else:\\n self.root.docs_paths = []\",\n \"def __init__(__self__, *,\\n autodefined_reverse_flag: pulumi.Input['ResolverConfigAutodefinedReverseFlag'],\\n resource_id: pulumi.Input[str]):\\n pulumi.set(__self__, \\\"autodefined_reverse_flag\\\", autodefined_reverse_flag)\\n pulumi.set(__self__, \\\"resource_id\\\", resource_id)\",\n \"def checklists(self, checklists):\\n\\n self._checklists = checklists\",\n \"def rotor_setting(self, rotor_setting):\\n rotor_setting = self.valid_ring_character(rotor_setting)\\n self._rot_offset = self._charset.index(rotor_setting)\",\n \"def _set_lsp_config_number_of_retries_configured(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name=\\\"lsp-config-number-of-retries-configured\\\", rest_name=\\\"lsp-config-number-of-retries-configured\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='boolean', is_config=True)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"lsp_config_number_of_retries_configured must be of a type compatible with boolean\\\"\\\"\\\",\\n 'defined-type': \\\"boolean\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=YANGBool, is_leaf=True, yang_name=\\\"lsp-config-number-of-retries-configured\\\", rest_name=\\\"lsp-config-number-of-retries-configured\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='boolean', is_config=True)\\\"\\\"\\\",\\n })\\n\\n self.__lsp_config_number_of_retries_configured = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def set_only_check_type(self, only_check_type=0):\\r\\n return self._arm.set_only_check_type(only_check_type)\",\n \"def with_manual_check_never(self):\\n self.__manual_check = constants.NEVER\\n return self\",\n \"def set_checklists_status(auth, args):\\n global checklists_on\\n\\n if auth['checklists'] == \\\"true\\\":\\n checklists_on = True\\n else:\\n checklists_on = False\\n\\n # reverse the config setting if specified by the CLI option\\n# if args['--checklists']:\\n# checklists_on = not checklists_on\\n\\n return\",\n \"def SetCanVeto(self, can_veto):\\r\\n\\r\\n self.canveto_flag = can_veto\",\n \"def published_committee_reference_parity_check(self, published_committee_reference_parity_check):\\n\\n self._published_committee_reference_parity_check = published_committee_reference_parity_check\",\n \"def __setAutoSpellChecking(self):\\n enabled = self.autoSpellCheckAct.isChecked()\\n Preferences.setEditor(\\\"AutoSpellCheckingEnabled\\\", enabled)\\n for editor in self.editors:\\n editor.setAutoSpellChecking()\",\n \"def setConsistencyChecks(self, *args):\\n return _libsbml.SBMLDocument_setConsistencyChecks(self, *args)\",\n \"def load_trust_anchors(self):\\n\\n utils.write_to_stdout(f\\\"{datetime.now()}: Loading RPKI Validator\\\\n\\\",\\n logging.root.level)\\n time.sleep(60)\\n while self._get_validation_status() is False:\\n time.sleep(10)\\n utils.write_to_stdout(\\\".\\\", logging.root.level)\\n utils.write_to_stdout(\\\"\\\\n\\\", logging.root.level)\\n self._wait(30, \\\"Waiting for upload to bgp preview\\\")\",\n \"def edit_config_verify(self,\\n raw_response: Any,\\n *args,\\n **kwargs) -> bool:\\n pass\",\n \"def checksum(self, check: bool):\\r\\n self._checksum = check\\r\\n self.checksum_hist.append(check)\",\n \"def can_verify(self, can_verify):\\n\\n self._can_verify = can_verify\",\n \"def setRevertable(self, b):\\n\\n self.revertable = b\",\n \"def setConsistencyChecksForConversion(self, *args):\\n return _libsbml.SBMLDocument_setConsistencyChecksForConversion(self, *args)\",\n \"def org_apache_felix_https_clientcertificate(self, org_apache_felix_https_clientcertificate: ConfigNodePropertyDropDown):\\n\\n self._org_apache_felix_https_clientcertificate = org_apache_felix_https_clientcertificate\",\n \"def syncheck(self, syncheck) :\\n\\t\\ttry :\\n\\t\\t\\tself._syncheck = syncheck\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def update_checker_setting(self, project_name, checker_name, enabled):\\n request_parms = {}\\n request_parms[\\\"action\\\"] = \\\"update_defect_type\\\"\\n request_parms[\\\"project\\\"] = project_name\\n request_parms[\\\"code\\\"] = checker_name\\n request_parms[\\\"enabled\\\"] = enabled\\n return self.send_request(request_parms)\",\n \"def SetTrusted(self, trusted):\\n self.__trusted = trusted\",\n \"def setTrustProxy(self, trustProxy):\\n pass\",\n \"def set_checked_ts(self, checked_ts):\\n self._checked_ts = checked_ts\",\n \"def __init__(__self__, *,\\n renewal_settings: Optional[pulumi.Input['GoogleCloudChannelV1RenewalSettingsArgs']] = None):\\n if renewal_settings is not None:\\n pulumi.set(__self__, \\\"renewal_settings\\\", renewal_settings)\",\n \"def set_lanzar(self):\\n self.lanzar = True\",\n \"def set_right_ascension(self, target_right_ascension):\\n self.right_ascension = target_right_ascension\\n return self.right_ascension\",\n \"def click_guarantee_cli_checkbox(self):\\n self.click_element(self.guarantee_cli_checkbox_locator)\",\n \"def trusted(self, trusted):\\n\\n self._trusted = trusted\",\n \"def autodefined_reverse_flag(self) -> pulumi.Output['ResolverConfigAutodefinedReverseFlag']:\\n return pulumi.get(self, \\\"autodefined_reverse_flag\\\")\",\n \"def set_reverse(rev):\\n global is_reverse\\n is_reverse = rev\",\n \"def rebalance_policy(self, rebalance_policy):\\n allowed_values = [\\\"auto\\\", \\\"manual\\\"]\\n if rebalance_policy is not None and rebalance_policy not in allowed_values:\\n raise ValueError(\\n \\\"Invalid value for `rebalance_policy`, must be one of {0}\\\"\\n .format(allowed_values)\\n )\\n\\n self._rebalance_policy = rebalance_policy\",\n \"def svn_fs_change_rev_prop(*args):\\r\\n return _fs.svn_fs_change_rev_prop(*args)\",\n \"def autodefined_reverse_flag(self) -> pulumi.Input['ResolverConfigAutodefinedReverseFlag']:\\n return pulumi.get(self, \\\"autodefined_reverse_flag\\\")\",\n \"def org_apache_felix_https_jetty_renegotiate_allowed(self, org_apache_felix_https_jetty_renegotiate_allowed: ConfigNodePropertyBoolean):\\n\\n self._org_apache_felix_https_jetty_renegotiate_allowed = org_apache_felix_https_jetty_renegotiate_allowed\",\n \"def test_revoked_cert(self):\\n\\n # Initially should be able to to operations like open a session\\n self._open_session()\\n HttpAgentRpc().remove_host(self.host.fqdn)\\n\\n # After revokation any access should be bounced\\n response = self._post([])\\n self.assertEqual(response.status_code, 403)\\n response = self._get()\\n self.assertEqual(response.status_code, 403)\",\n \"def command_preflight_check(self):\\n checks_pass, failures = self.environment.perform_preflight_check()\\n if checks_pass:\\n print('All checks pass.')\\n else:\\n sys.stderr.write('Problems encountered:\\\\n')\\n for msg in failures:\\n sys.stderr.write(' - %s\\\\n' % msg)\\n sys.exit(1)\",\n \"def _set_lsp_frr_computation_mode_use_bypass_liberal(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name=\\\"lsp-frr-computation-mode-use-bypass-liberal\\\", rest_name=\\\"lsp-frr-computation-mode-use-bypass-liberal\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='boolean', is_config=True)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"lsp_frr_computation_mode_use_bypass_liberal must be of a type compatible with boolean\\\"\\\"\\\",\\n 'defined-type': \\\"boolean\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=YANGBool, is_leaf=True, yang_name=\\\"lsp-frr-computation-mode-use-bypass-liberal\\\", rest_name=\\\"lsp-frr-computation-mode-use-bypass-liberal\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='boolean', is_config=True)\\\"\\\"\\\",\\n })\\n\\n self.__lsp_frr_computation_mode_use_bypass_liberal = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def set_remit_to_address(self, remit_to_address):\\n self.remit_to_address = remit_to_address\",\n \"def auto_resume_at_loser(self, auto_resume_at_loser):\\n\\n self._auto_resume_at_loser = auto_resume_at_loser\",\n \"def fill_disable_ssl_verification(self, data):\\n disable_ssl_verification = get_optional_value(data, self.DISABLE_SSL, False)\\n self.verify_ssl = not bool(disable_ssl_verification)\",\n \"def _set_lsp_config_frr_configured(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name=\\\"lsp-config-frr-configured\\\", rest_name=\\\"lsp-config-frr-configured\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='boolean', is_config=True)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"lsp_config_frr_configured must be of a type compatible with boolean\\\"\\\"\\\",\\n 'defined-type': \\\"boolean\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=YANGBool, is_leaf=True, yang_name=\\\"lsp-config-frr-configured\\\", rest_name=\\\"lsp-config-frr-configured\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='boolean', is_config=True)\\\"\\\"\\\",\\n })\\n\\n self.__lsp_config_frr_configured = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def setViewerPreferences(self,viewerPreferences):\\n self.PDFreactorConfiguration.in1[\\\"viewerPreferences\\\"] = viewerPreferences\",\n \"def client_cert(self, client_cert):\\n\\n self._client_cert = client_cert\",\n \"def setRefDelay (self, ra, dec):\\n self._response.setRefDelay(ra, dec)\",\n \"def ocsp_revoked(self, cert_path, chain_path):\\n if self.broken:\\n return False\\n\\n\\n url, host = self.determine_ocsp_server(cert_path)\\n if not host:\\n return False\\n # jdkasten thanks \\\"Bulletproof SSL and TLS - Ivan Ristic\\\" for documenting this!\\n cmd = [\\\"openssl\\\", \\\"ocsp\\\",\\n \\\"-no_nonce\\\",\\n \\\"-issuer\\\", chain_path,\\n \\\"-cert\\\", cert_path,\\n \\\"-url\\\", url,\\n \\\"-CAfile\\\", chain_path,\\n \\\"-verify_other\\\", chain_path,\\n \\\"-trust_other\\\",\\n \\\"-header\\\"] + self.host_args(host)\\n logger.debug(\\\"Querying OCSP for %s\\\", cert_path)\\n logger.debug(\\\" \\\".join(cmd))\\n try:\\n output, err = util.run_script(cmd, log=logger.debug)\\n except errors.SubprocessError:\\n logger.info(\\\"OCSP check failed for %s (are we offline?)\\\", cert_path)\\n return False\\n\\n return _translate_ocsp_query(cert_path, output, err)\",\n \"def __check_opts(self):\\n self.ca_cert_file = os.environ['HOME'] + '/.cat_installer/ca.pem'\\n self.pfx_file = os.environ['HOME'] + '/.cat_installer/user.p12'\\n if not os.path.isfile(self.ca_cert_file):\\n print(Messages.cert_error)\\n sys.exit(2)\",\n \"def create_verification_overriding_cfg(self, resource_type=None,\\n resource_ref=None,\\n resource_action=None,\\n impersonation_allowed=False):\\n imp_allowed = impersonation_allowed\\n if impersonation_allowed is None:\\n imp_allowed = False\\n\\n resp = self.create_verification(\\n resource_type=resource_type or self.config.resource_type,\\n resource_ref=resource_ref or self.config.resource_ref,\\n resource_action=resource_action or self.config.resource_action,\\n impersonation_allowed=imp_allowed)\\n\\n return resp\",\n \"def set_in_check(self, state):\\n\\n self._in_check = state\",\n \"def verify_crl(cert, path, validation_context, use_deltas=True, cert_description=None, end_entity_name_override=None):\\n\\n if not isinstance(cert, x509.Certificate):\\n raise TypeError(pretty_message(\\n '''\\n cert must be an instance of asn1crypto.x509.Certificate, not %s\\n ''',\\n type_name(cert)\\n ))\\n\\n if not isinstance(path, ValidationPath):\\n raise TypeError(pretty_message(\\n '''\\n path must be an instance of certvalidator.path.ValidationPath,\\n not %s\\n ''',\\n type_name(path)\\n ))\\n\\n if not isinstance(validation_context, ValidationContext):\\n raise TypeError(pretty_message(\\n '''\\n validation_context must be an instance of\\n certvalidator.context.ValidationContext, not %s\\n ''',\\n type_name(validation_context)\\n ))\\n\\n if cert_description is None:\\n cert_description = 'the certificate'\\n\\n if not isinstance(cert_description, str_cls):\\n raise TypeError(pretty_message(\\n '''\\n cert_description must be a unicode string, not %s\\n ''',\\n type_name(cert_description)\\n ))\\n\\n moment = validation_context.moment\\n certificate_registry = validation_context.certificate_registry\\n\\n certificate_lists = validation_context.retrieve_crls(cert)\\n\\n cert_issuer = path.find_issuer(cert)\\n\\n complete_lists_by_issuer = {}\\n delta_lists_by_issuer = {}\\n for certificate_list in certificate_lists:\\n issuer_hashable = certificate_list.issuer.hashable\\n if certificate_list.delta_crl_indicator_value is None:\\n if issuer_hashable not in complete_lists_by_issuer:\\n complete_lists_by_issuer[issuer_hashable] = []\\n complete_lists_by_issuer[issuer_hashable].append(certificate_list)\\n else:\\n if issuer_hashable not in delta_lists_by_issuer:\\n delta_lists_by_issuer[issuer_hashable] = []\\n delta_lists_by_issuer[issuer_hashable].append(certificate_list)\\n\\n # In the main loop, only complete CRLs are processed, so delta CRLs are\\n # weeded out of the todo list\\n crls_to_process = []\\n for issuer_crls in complete_lists_by_issuer.values():\\n crls_to_process.extend(issuer_crls)\\n total_crls = len(crls_to_process)\\n\\n # Build a lookup table for the Distribution point objects associated with\\n # an issuer name hashable\\n distribution_point_map = {}\\n sources = [cert.crl_distribution_points]\\n if use_deltas:\\n sources.extend(cert.delta_crl_distribution_points)\\n for dp_list in sources:\\n for distribution_point in dp_list:\\n if isinstance(distribution_point['crl_issuer'], x509.GeneralNames):\\n dp_name_hashes = []\\n for general_name in distribution_point['crl_issuer']:\\n if general_name.name == 'directory_name':\\n dp_name_hashes.append(general_name.chosen.hashable)\\n else:\\n dp_name_hashes = [cert.issuer.hashable]\\n for dp_name_hash in dp_name_hashes:\\n if dp_name_hash not in distribution_point_map:\\n distribution_point_map[dp_name_hash] = []\\n distribution_point_map[dp_name_hash].append(distribution_point)\\n\\n valid_reasons = set([\\n 'key_compromise',\\n 'ca_compromise',\\n 'affiliation_changed',\\n 'superseded',\\n 'cessation_of_operation',\\n 'certificate_hold',\\n 'privilege_withdrawn',\\n 'aa_compromise',\\n ])\\n\\n known_extensions = set([\\n 'issuer_alt_name',\\n 'crl_number',\\n 'delta_crl_indicator',\\n 'issuing_distribution_point',\\n 'authority_key_identifier',\\n 'freshest_crl',\\n 'authority_information_access',\\n ])\\n\\n checked_reasons = set()\\n\\n failures = []\\n issuer_failures = 0\\n\\n while len(crls_to_process) > 0:\\n certificate_list = crls_to_process.pop(0)\\n crl_idp = certificate_list.issuing_distribution_point_value\\n delta_certificate_list = None\\n delta_crl_idp = None\\n\\n interim_reasons = set()\\n\\n crl_issuer = None\\n crl_issuer_name = None\\n is_indirect = False\\n\\n if crl_idp and crl_idp['indirect_crl'].native:\\n is_indirect = True\\n crl_idp_name = crl_idp['distribution_point']\\n if crl_idp_name:\\n if crl_idp_name.name == 'full_name':\\n crl_issuer_name = crl_idp_name.chosen[0].chosen\\n else:\\n crl_issuer_name = cert_issuer.subject.copy().chosen.append(\\n crl_idp_name.chosen\\n )\\n elif certificate_list.authority_key_identifier:\\n tmp_crl_issuer = certificate_registry.retrieve_by_key_identifier(\\n certificate_list.authority_key_identifier\\n )\\n crl_issuer_name = tmp_crl_issuer.subject\\n else:\\n failures.append((\\n 'CRL is marked as an indirect CRL, but provides no '\\n 'mechanism for locating the CRL issuer certificate',\\n certificate_list\\n ))\\n continue\\n else:\\n crl_issuer_name = certificate_list.issuer\\n\\n if not crl_issuer:\\n crl_issuer = validation_context.check_crl_issuer(certificate_list)\\n\\n if not crl_issuer:\\n candidate_crl_issuers = certificate_registry.retrieve_by_name(crl_issuer_name, cert_issuer)\\n candidates_skipped = 0\\n signatures_failed = 0\\n unauthorized_certs = 0\\n\\n if not candidate_crl_issuers and crl_issuer_name != certificate_list.issuer:\\n candidate_crl_issuers = certificate_registry.retrieve_by_name(certificate_list.issuer, cert_issuer)\\n\\n for candidate_crl_issuer in candidate_crl_issuers:\\n direct_issuer = candidate_crl_issuer.subject == cert_issuer.subject\\n\\n # In some cases an indirect CRL issuer is a certificate issued\\n # by the certificate issuer. However, we need to ensure that\\n # the candidate CRL issuer is not the certificate being checked,\\n # otherwise we may be checking an incorrect CRL and produce\\n # incorrect results.\\n indirect_issuer = candidate_crl_issuer.issuer == cert_issuer.subject\\n indirect_issuer = indirect_issuer and candidate_crl_issuer.sha256 != cert.sha256\\n\\n if not direct_issuer and not indirect_issuer and not is_indirect:\\n candidates_skipped += 1\\n continue\\n\\n # Step f\\n candidate_crl_issuer_path = None\\n\\n if validation_context:\\n candidate_crl_issuer_path = validation_context.check_validation(candidate_crl_issuer)\\n\\n if candidate_crl_issuer_path is None:\\n candidate_crl_issuer_path = path.copy().truncate_to_issuer(candidate_crl_issuer)\\n candidate_crl_issuer_path.append(candidate_crl_issuer)\\n try:\\n # Pre-emptively mark a path as validated to prevent recursion\\n if validation_context:\\n validation_context.record_validation(candidate_crl_issuer, candidate_crl_issuer_path)\\n\\n temp_override = end_entity_name_override\\n if temp_override is None and candidate_crl_issuer.sha256 != cert_issuer.sha256:\\n temp_override = cert_description + ' CRL issuer'\\n _validate_path(\\n validation_context,\\n candidate_crl_issuer_path,\\n end_entity_name_override=temp_override\\n )\\n\\n except (PathValidationError) as e:\\n # If the validation did not work out, clear it\\n if validation_context:\\n validation_context.clear_validation(candidate_crl_issuer)\\n\\n # We let a revoked error fall through since step k will catch\\n # it with a correct error message\\n if isinstance(e, RevokedError):\\n raise\\n raise CRLValidationError('CRL issuer certificate path could not be validated')\\n\\n key_usage_value = candidate_crl_issuer.key_usage_value\\n if key_usage_value and 'crl_sign' not in key_usage_value.native:\\n unauthorized_certs += 1\\n continue\\n\\n try:\\n # Step g\\n _verify_signature(certificate_list, candidate_crl_issuer)\\n\\n crl_issuer = candidate_crl_issuer\\n break\\n\\n except (CRLValidationError):\\n signatures_failed += 1\\n continue\\n\\n if crl_issuer is None:\\n if candidates_skipped == len(candidate_crl_issuers):\\n issuer_failures += 1\\n else:\\n if signatures_failed == len(candidate_crl_issuers):\\n failures.append((\\n 'CRL signature could not be verified',\\n certificate_list\\n ))\\n elif unauthorized_certs == len(candidate_crl_issuers):\\n failures.append((\\n 'The CRL issuer is not authorized to sign CRLs',\\n certificate_list\\n ))\\n else:\\n failures.append((\\n 'Unable to locate CRL issuer certificate',\\n certificate_list\\n ))\\n continue\\n else:\\n validation_context.record_crl_issuer(certificate_list, crl_issuer)\\n\\n # Step b 1\\n has_dp_crl_issuer = False\\n dp_match = False\\n\\n dps = cert.crl_distribution_points_value\\n if dps:\\n crl_issuer_general_name = x509.GeneralName(\\n name='directory_name',\\n value=crl_issuer.subject\\n )\\n for dp in dps:\\n if dp['crl_issuer']:\\n has_dp_crl_issuer = True\\n if crl_issuer_general_name in dp['crl_issuer']:\\n dp_match = True\\n\\n same_issuer = crl_issuer.subject == cert_issuer.subject\\n indirect_match = has_dp_crl_issuer and dp_match and is_indirect\\n missing_idp = has_dp_crl_issuer and (not dp_match or not is_indirect)\\n indirect_crl_issuer = crl_issuer.issuer == cert_issuer.subject\\n\\n if (not same_issuer and not indirect_match and not indirect_crl_issuer) or missing_idp:\\n issuer_failures += 1\\n continue\\n\\n # Check to make sure the CRL is valid for the moment specified\\n if moment < certificate_list['tbs_cert_list']['this_update'].native:\\n failures.append((\\n 'CRL is from after the validation time',\\n certificate_list\\n ))\\n continue\\n if moment > certificate_list['tbs_cert_list']['next_update'].native:\\n failures.append((\\n 'CRL should have been regenerated by the validation time',\\n certificate_list\\n ))\\n continue\\n\\n # Step b 2\\n\\n if crl_idp is not None:\\n # Step b 2 i\\n has_idp_name = False\\n has_dp_name = False\\n idp_dp_match = False\\n\\n idp_general_names = []\\n idp_dp_name = crl_idp['distribution_point']\\n if idp_dp_name:\\n has_idp_name = True\\n if idp_dp_name.name == 'full_name':\\n for general_name in idp_dp_name.chosen:\\n idp_general_names.append(general_name)\\n else:\\n inner_extended_issuer_name = crl_issuer.subject.copy()\\n inner_extended_issuer_name.chosen.append(idp_dp_name.chosen.untag())\\n idp_general_names.append(x509.GeneralName(\\n name='directory_name',\\n value=inner_extended_issuer_name\\n ))\\n\\n dps = cert.crl_distribution_points_value\\n if dps:\\n for dp in dps:\\n if idp_dp_match:\\n break\\n dp_name = dp['distribution_point']\\n if dp_name:\\n has_dp_name = True\\n if dp_name.name == 'full_name':\\n for general_name in dp_name.chosen:\\n if general_name in idp_general_names:\\n idp_dp_match = True\\n break\\n else:\\n inner_extended_issuer_name = crl_issuer.subject.copy()\\n inner_extended_issuer_name.chosen.append(dp_name.chosen.untag())\\n dp_extended_issuer_name = x509.GeneralName(\\n name='directory_name',\\n value=inner_extended_issuer_name\\n )\\n\\n if dp_extended_issuer_name in idp_general_names:\\n idp_dp_match = True\\n\\n elif dp['crl_issuer']:\\n has_dp_name = True\\n for dp_crl_issuer_name in dp['crl_issuer']:\\n if dp_crl_issuer_name in idp_general_names:\\n idp_dp_match = True\\n break\\n else:\\n # If there is no DP, we consider the CRL issuer name to be it\\n has_dp_name = True\\n general_name = x509.GeneralName(\\n name='directory_name',\\n value=crl_issuer_name\\n )\\n if general_name in idp_general_names:\\n idp_dp_match = True\\n\\n idp_dp_match_failed = has_idp_name and has_dp_name and not idp_dp_match\\n\\n if idp_dp_match_failed:\\n failures.append((\\n pretty_message(\\n '''\\n The CRL issuing distribution point extension does not\\n share any names with the certificate CRL distribution\\n point extension\\n '''\\n ),\\n certificate_list\\n ))\\n issuer_failures += 1\\n continue\\n\\n # Step b 2 ii\\n if crl_idp['only_contains_user_certs'].native:\\n if cert.basic_constraints_value and cert.basic_constraints_value['ca'].native:\\n failures.append((\\n pretty_message(\\n '''\\n CRL only contains end-entity certificates and\\n certificate is a CA certificate\\n '''\\n ),\\n certificate_list\\n ))\\n continue\\n\\n # Step b 2 iii\\n if crl_idp['only_contains_ca_certs'].native:\\n if not cert.basic_constraints_value or cert.basic_constraints_value['ca'].native is False:\\n failures.append((\\n pretty_message(\\n '''\\n CRL only contains CA certificates and certificate\\n is an end-entity certificate\\n '''\\n ),\\n certificate_list\\n ))\\n continue\\n\\n # Step b 2 iv\\n if crl_idp['only_contains_attribute_certs'].native:\\n failures.append((\\n 'CRL only contains attribute certificates',\\n certificate_list\\n ))\\n continue\\n\\n # Step c\\n if use_deltas and certificate_list.freshest_crl_value and len(certificate_list.freshest_crl_value) > 0:\\n for candidate_delta_cl in delta_lists_by_issuer.get(crl_issuer_name.hashable, []):\\n\\n # Step c 1\\n if candidate_delta_cl.issuer != crl_issuer_name:\\n continue\\n\\n # Step c 2\\n delta_crl_idp = candidate_delta_cl.issuing_distribution_point_value\\n if (crl_idp is None and delta_crl_idp is not None) or (crl_idp is not None and delta_crl_idp is None):\\n continue\\n\\n if crl_idp and crl_idp.native != delta_crl_idp.native:\\n continue\\n\\n # Step c 3\\n if certificate_list.authority_key_identifier != candidate_delta_cl.authority_key_identifier:\\n continue\\n\\n delta_certificate_list = candidate_delta_cl\\n break\\n\\n # Step d\\n idp_reasons = None\\n\\n if crl_idp and crl_idp['only_some_reasons'].native is not None:\\n idp_reasons = crl_idp['only_some_reasons'].native\\n\\n reason_keys = None\\n if idp_reasons:\\n reason_keys = idp_reasons\\n\\n if reason_keys is None:\\n interim_reasons = valid_reasons.copy()\\n else:\\n interim_reasons = reason_keys\\n\\n # Step e\\n # We don't skip a CRL if it only contains reasons already checked since\\n # a certificate issuer can self-issue a new cert that is used for CRLs\\n\\n if certificate_list.critical_extensions - known_extensions:\\n failures.append((\\n 'One or more unrecognized critical extensions are present in '\\n 'the CRL',\\n certificate_list\\n ))\\n continue\\n\\n if use_deltas and delta_certificate_list and delta_certificate_list.critical_extensions - known_extensions:\\n failures.append((\\n 'One or more unrecognized critical extensions are present in '\\n 'the delta CRL',\\n delta_certificate_list\\n ))\\n continue\\n\\n # Step h\\n if use_deltas and delta_certificate_list:\\n try:\\n _verify_signature(delta_certificate_list, crl_issuer)\\n except (CRLValidationError):\\n failures.append((\\n 'Delta CRL signature could not be verified',\\n certificate_list,\\n delta_certificate_list\\n ))\\n continue\\n\\n if moment < delta_certificate_list['tbs_cert_list']['this_update'].native:\\n failures.append((\\n 'Delta CRL is from after the validation time',\\n certificate_list,\\n delta_certificate_list\\n ))\\n continue\\n if moment > delta_certificate_list['tbs_cert_list']['next_update'].native:\\n failures.append((\\n 'Delta CRL is from before the validation time',\\n certificate_list,\\n delta_certificate_list\\n ))\\n continue\\n\\n # Step i\\n revoked_reason = None\\n revoked_date = None\\n\\n if use_deltas and delta_certificate_list:\\n try:\\n revoked_date, revoked_reason = _find_cert_in_list(cert, cert_issuer, delta_certificate_list, crl_issuer)\\n except (NotImplementedError):\\n failures.append((\\n 'One or more critical extensions are present in the CRL '\\n 'entry for the certificate',\\n delta_certificate_list\\n ))\\n continue\\n\\n # Step j\\n if revoked_reason is None:\\n try:\\n revoked_date, revoked_reason = _find_cert_in_list(cert, cert_issuer, certificate_list, crl_issuer)\\n except (NotImplementedError):\\n failures.append((\\n 'One or more critical extensions are present in the CRL '\\n 'entry for the certificate',\\n certificate_list\\n ))\\n continue\\n\\n # Step k\\n if revoked_reason and revoked_reason.native == 'remove_from_crl':\\n revoked_reason = None\\n revoked_date = None\\n\\n if revoked_reason:\\n reason = revoked_reason.human_friendly\\n date = revoked_date.native.strftime('%Y-%m-%d')\\n time = revoked_date.native.strftime('%H:%M:%S')\\n raise RevokedError(pretty_message(\\n '''\\n CRL indicates %s was revoked at %s on %s, due to %s\\n ''',\\n cert_description,\\n time,\\n date,\\n reason\\n ))\\n\\n # Step l\\n checked_reasons |= interim_reasons\\n\\n # CRLs should not include this value, but at least one of the examples\\n # from the NIST test suite does\\n checked_reasons -= set(['unused'])\\n\\n if checked_reasons != valid_reasons:\\n if total_crls == issuer_failures:\\n raise CRLNoMatchesError(pretty_message(\\n '''\\n No CRLs were issued by the issuer of %s, or any indirect CRL\\n issuer\\n ''',\\n cert_description\\n ))\\n\\n if not failures:\\n failures.append((\\n 'The available CRLs do not cover all revocation reasons',\\n ))\\n\\n raise CRLValidationIndeterminateError(\\n pretty_message(\\n '''\\n Unable to determine if %s is revoked due to insufficient\\n information from known CRLs\\n ''',\\n cert_description\\n ),\\n failures\\n )\",\n \"def set_checked(self, checked):\\n self._checked = checked\",\n \"def on_reencryptCheckBox_toggled(self, on):\\n self.__updateUI()\",\n \"def setCleanupTool(self,value):\\n self.PDFreactorConfiguration.in1[\\\"cleanupTool\\\"] = value\",\n \"def __init__(self, check_revocation=None, console_ca_cert=None, console_custom_cert=None, hpkp=None, local_vars_configuration=None): # noqa: E501 # noqa: E501\\n if local_vars_configuration is None:\\n local_vars_configuration = Configuration.get_default_copy()\\n self.local_vars_configuration = local_vars_configuration\\n\\n self._check_revocation = None\\n self._console_ca_cert = None\\n self._console_custom_cert = None\\n self._hpkp = None\\n self.discriminator = None\\n\\n if check_revocation is not None:\\n self.check_revocation = check_revocation\\n if console_ca_cert is not None:\\n self.console_ca_cert = console_ca_cert\\n if console_custom_cert is not None:\\n self.console_custom_cert = console_custom_cert\\n if hpkp is not None:\\n self.hpkp = hpkp\",\n \"def test_rotate_certificates(self):\\n self.x509.generate_multiple_x509_certs(servers=self.servers)\\n self.log.info(\\\"Manifest before rotating certs #########\\\\n {0}\\\".\\n format(json.dumps(self.x509.manifest, indent=4)))\\n for server in self.servers[:self.nodes_init]:\\n _ = self.x509.upload_root_certs(server)\\n self.x509.upload_node_certs(servers=self.servers[:self.nodes_init])\\n self.x509.delete_unused_out_of_the_box_CAs(server=self.master)\\n self.x509.upload_client_cert_settings(server=self.servers[0])\\n self.log.info(\\\"Checking authentication ...\\\")\\n self.auth(servers=self.servers[:self.nodes_init])\\n self.x509.rotate_certs(self.servers, \\\"all\\\")\\n self.log.info(\\\"Manifest after rotating certs #########\\\\n {0}\\\".\\n format(json.dumps(self.x509.manifest, indent=4)))\\n\\n https_val = CbServer.use_https # so that add_node uses https\\n CbServer.use_https = True\\n task = self.cluster.async_rebalance(self.servers[:self.nodes_init],\\n self.servers[self.nodes_init:], [])\\n self.wait_for_rebalance_to_complete(task)\\n CbServer.use_https = https_val\\n self.log.info(\\\"Checking authentication ...\\\")\\n self.auth(servers=self.servers)\\n content = self.x509.get_trusted_CAs()\\n self.log.info(\\\"Trusted CAs: {0}\\\".format(content))\\n self.log.info(\\\"Active Root CAs names {0}\\\".format(self.x509.root_ca_names))\",\n \"def set(self, boolean):\\n self._val = boolean\",\n \"def console_ca_cert(self, console_ca_cert):\\n\\n self._console_ca_cert = console_ca_cert\",\n \"def test_set_verify_callback_reference(self):\\n\\n def callback(conn, cert, errnum, depth, ok): # pragma: no cover\\n return ok\\n\\n tracker = ref(callback)\\n\\n context = Context(SSLv23_METHOD)\\n context.set_verify(VERIFY_PEER, callback)\\n del callback\\n\\n conn = Connection(context, None)\\n context.set_verify(VERIFY_NONE)\\n\\n collect()\\n collect()\\n assert tracker()\\n\\n conn.set_verify(VERIFY_PEER, lambda conn, cert, errnum, depth, ok: ok)\\n collect()\\n collect()\\n callback = tracker()\\n if callback is not None: # pragma: nocover\\n referrers = get_referrers(callback)\\n if len(referrers) > 1:\\n pytest.fail(\\\"Some references remain: %r\\\" % (referrers,))\",\n \"def verified(self, verified):\\n\\n self._verified = verified\",\n \"def cert(self, value):\\n self._cert = value\",\n \"def server_auth_crl_ids(self, server_auth_crl_ids):\\n\\n self._server_auth_crl_ids = server_auth_crl_ids\",\n \"def test_is_revoked_target(self):\\n self.site.mode = SITE_MODE_SOURCE\\n self.site.save()\\n self.assertEqual(self.project.is_revoked(), False)\\n self.remote_project.level = SODAR_CONSTANTS['REMOTE_LEVEL_REVOKED']\\n self.remote_project.save()\\n self.assertEqual(self.project.is_revoked(), True)\",\n \"def set_check_interval (self, interval):\\n\\t\\tif self.__timeout:\\n\\t\\t\\tgobject.source_remove(self.__timeout)\\n\\t\\tself.__timeout = gobject.timeout_add(interval * 60000, \\n\\t\\t\\tself.run_mailcheck)\",\n \"def trusted_server_certificates(self, trusted_server_certificates):\\n if trusted_server_certificates is not None and len(trusted_server_certificates) > 100000:\\n raise ValueError(\\\"Invalid value for `trusted_server_certificates`, length must be less than or equal to `100000`\\\")\\n if trusted_server_certificates is not None and len(trusted_server_certificates) < 0:\\n raise ValueError(\\\"Invalid value for `trusted_server_certificates`, length must be greater than or equal to `0`\\\")\\n\\n self._trusted_server_certificates = trusted_server_certificates\",\n \"def __init__(__self__, *,\\n cross_subscription_restore_settings: Optional['outputs.CrossSubscriptionRestoreSettingsResponse'] = None):\\n if cross_subscription_restore_settings is not None:\\n pulumi.set(__self__, \\\"cross_subscription_restore_settings\\\", cross_subscription_restore_settings)\",\n \"def set_recharge(self, recharge):\\n self.__recharge = recharge\",\n \"def check(self, verifier = None):\\n for (k, v) in self._versions.items():\\n #print(k,v)\\n if k == 'KLEE':\\n # check KLEE only if we are using KLEE\\n if verifier.startswith('klee'):\\n vers = self._get_klee_version()\\n expected = self._decode(v)\\n self._check(k, expected, vers)\\n elif k == 'sbt-slicer':\\n vers = self._get_slicer_version()\\n expected = self._decode(v[:8])\\n self._check(k, expected, vers)\\n elif k == 'sbt-instrumentation':\\n vers = self._get_instr_version()\\n expected = self._decode(v[:8])\\n self._check(k, expected, vers)\",\n \"def renewable(self, renewable):\\n if renewable is None:\\n raise ValueError(\\\"Invalid value for `renewable`, must not be `None`\\\") # noqa: E501\\n\\n self._renewable = renewable\",\n \"def revoke_certificate(self):\\n return self.__query(\\\"certificateRevoke\\\", kwargs)\",\n \"def checkin(self, checkin):\\n\\n self._checkin = checkin\",\n \"def HasRestoredProp(self, flag):\\n\\n if flag:\\n self._hasRestored = flag\",\n \"def svn_info_t_rev_set(svn_info_t_self, svn_revnum_t_rev): # real signature unknown; restored from __doc__\\n pass\",\n \"def runoff_election(self, runoff_election):\\n\\n self._runoff_election = runoff_election\",\n \"def remittance_reference(self, remittance_reference):\\n\\n self._remittance_reference = remittance_reference\",\n \"def y_flag(self):\\n if self.calibrationlog:\\n self.calibrationlogflag = True\\n self.calibrationlogtime = DEFAULT_CALIBRATIONLOG_TIME\",\n \"def preferred_certificates(self, preferred_certificates):\\n\\n self._preferred_certificates = preferred_certificates\",\n \"def _set_lsp_config_number_of_retries(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\\\"lsp-config-number-of-retries\\\", rest_name=\\\"lsp-config-number-of-retries\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='uint32', is_config=True)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"lsp_config_number_of_retries must be of a type compatible with uint32\\\"\\\"\\\",\\n 'defined-type': \\\"uint32\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=RestrictedClassType(base_type=long, restriction_dict={'range': ['0..4294967295']}, int_size=32), is_leaf=True, yang_name=\\\"lsp-config-number-of-retries\\\", rest_name=\\\"lsp-config-number-of-retries\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='urn:brocade.com:mgmt:brocade-mpls', defining_module='brocade-mpls', yang_type='uint32', is_config=True)\\\"\\\"\\\",\\n })\\n\\n self.__lsp_config_number_of_retries = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def rotateAfterCheckChanged(self, state):\\n if state == QtCore.Qt.Unchecked:\\n self.rotateAfter = False\\n\\n else:\\n self.rotateAfter = True\",\n \"def set_wraperror(self, value: bool = True) -> None:\\n self.WRAPERROR = tools.coerce_bool(value)\",\n \"def set_right_trig(self, trig):\\n\\t\\tself.right_trig = trig\",\n \"def initialize_options(self):\\n self.branch = \\\"master\\\"\\n self.fix = False\\n super(lint, self).initialize_options()\",\n \"def set_rx_calibrate (self, rx_calibrate):\\n\\t\\tif ((rx_calibrate == 0) or (rx_calibrate == 1)):\\n\\t\\t\\tself._rx_calibrate = rx_calibrate\\n\\t\\telse:\\n\\t\\t\\tsys.stderr.write(\\\"\\\\nERROR : %s rx_calibrate must be 0 (disabled) or 1 (enabled) so it can't be %s !\\\\n\\\" % (self._target_id, rx_calibrate))\\n\\t\\t\\tsys.exit(1)\",\n \"def __reference_frame_checkbox(self, c):\\n if len(self.__robots) > 0:\\n self.__robots[self.__selected_robot].set_reference_visibility(\\n c.checked)\",\n \"def setHandshakeOp(self, handshaker):\\r\\n try:\\r\\n self._checkAssert(0)\\r\\n self.handshaker = handshaker\\r\\n self._doHandshakeOp()\\r\\n except:\\r\\n self._clear()\\r\\n raise\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.50971395","0.45247346","0.4501634","0.44256946","0.43760172","0.43499175","0.43033206","0.42995754","0.42879218","0.42419428","0.42351454","0.42196298","0.41943878","0.41834015","0.4180629","0.4163931","0.4148873","0.41426238","0.41319498","0.41168395","0.41144472","0.4064841","0.40640843","0.40596324","0.40430415","0.4030526","0.40212867","0.4011426","0.40088424","0.4003236","0.40005895","0.3960791","0.3950629","0.39484802","0.3948053","0.39454293","0.39251432","0.39224228","0.39088735","0.3908291","0.38950476","0.38750434","0.38738662","0.38720167","0.38535777","0.3848833","0.3847176","0.3842058","0.38352355","0.38304895","0.38177702","0.38123158","0.38109893","0.38003963","0.37964758","0.3794628","0.37924388","0.37915316","0.37898406","0.37873527","0.378544","0.37833524","0.37821335","0.37774423","0.37665436","0.3765367","0.3762197","0.37581474","0.37524757","0.375016","0.37426353","0.37256935","0.37239432","0.37234432","0.37214047","0.37186927","0.3717874","0.37132156","0.37106085","0.371008","0.37057522","0.36931854","0.3678176","0.3676775","0.36758584","0.36717638","0.3669897","0.36691818","0.36648092","0.3657777","0.36567476","0.36547792","0.36547","0.36531296","0.36479488","0.3647061","0.36456695","0.36378217","0.3635594","0.36354557"],"string":"[\n \"0.50971395\",\n \"0.45247346\",\n \"0.4501634\",\n \"0.44256946\",\n \"0.43760172\",\n \"0.43499175\",\n \"0.43033206\",\n \"0.42995754\",\n \"0.42879218\",\n \"0.42419428\",\n \"0.42351454\",\n \"0.42196298\",\n \"0.41943878\",\n \"0.41834015\",\n \"0.4180629\",\n \"0.4163931\",\n \"0.4148873\",\n \"0.41426238\",\n \"0.41319498\",\n \"0.41168395\",\n \"0.41144472\",\n \"0.4064841\",\n \"0.40640843\",\n \"0.40596324\",\n \"0.40430415\",\n \"0.4030526\",\n \"0.40212867\",\n \"0.4011426\",\n \"0.40088424\",\n \"0.4003236\",\n \"0.40005895\",\n \"0.3960791\",\n \"0.3950629\",\n \"0.39484802\",\n \"0.3948053\",\n \"0.39454293\",\n \"0.39251432\",\n \"0.39224228\",\n \"0.39088735\",\n \"0.3908291\",\n \"0.38950476\",\n \"0.38750434\",\n \"0.38738662\",\n \"0.38720167\",\n \"0.38535777\",\n \"0.3848833\",\n \"0.3847176\",\n \"0.3842058\",\n \"0.38352355\",\n \"0.38304895\",\n \"0.38177702\",\n \"0.38123158\",\n \"0.38109893\",\n \"0.38003963\",\n \"0.37964758\",\n \"0.3794628\",\n \"0.37924388\",\n \"0.37915316\",\n \"0.37898406\",\n \"0.37873527\",\n \"0.378544\",\n \"0.37833524\",\n \"0.37821335\",\n \"0.37774423\",\n \"0.37665436\",\n \"0.3765367\",\n \"0.3762197\",\n \"0.37581474\",\n \"0.37524757\",\n \"0.375016\",\n \"0.37426353\",\n \"0.37256935\",\n \"0.37239432\",\n \"0.37234432\",\n \"0.37214047\",\n \"0.37186927\",\n \"0.3717874\",\n \"0.37132156\",\n \"0.37106085\",\n \"0.371008\",\n \"0.37057522\",\n \"0.36931854\",\n \"0.3678176\",\n \"0.3676775\",\n \"0.36758584\",\n \"0.36717638\",\n \"0.3669897\",\n \"0.36691818\",\n \"0.36648092\",\n \"0.3657777\",\n \"0.36567476\",\n \"0.36547792\",\n \"0.36547\",\n \"0.36531296\",\n \"0.36479488\",\n \"0.3647061\",\n \"0.36456695\",\n \"0.36378217\",\n \"0.3635594\",\n \"0.36354557\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7481139"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":24573,"cells":{"query":{"kind":"string","value":"Sets the console_ca_cert of this TypesConsoleCertificateSettings."},"document":{"kind":"string","value":"def console_ca_cert(self, console_ca_cert):\n\n self._console_ca_cert = console_ca_cert"},"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 ca_cert(self, ca_cert):\n\n self._ca_cert = ca_cert","def console_custom_cert(self, console_custom_cert):\n\n self._console_custom_cert = console_custom_cert","def ca_cert_path(self, ca_cert_path: str):\n\n self._ca_cert_path = ca_cert_path","def save_ca():\n cert_file = os.environ.get('HOME') + '/.cat_installer/ca.pem'\n debug(\"saving cert\")\n with open(cert_file, 'w') as cert:\n cert.write(Config.CA + \"\\n\")","def cert(self, value):\n self._cert = value","def ca_certificate(self) -> str:\n return pulumi.get(self, \"ca_certificate\")","def ca_certificate(self) -> str:\n return pulumi.get(self, \"ca_certificate\")","def ca_certificate(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"ca_certificate\")","def test_set_one_ca_list(self):\n cacert = load_certificate(FILETYPE_PEM, root_cert_pem)\n cadesc = cacert.get_subject()\n\n def single_ca(ctx):\n ctx.set_client_ca_list([cadesc])\n return [cadesc]\n\n self._check_client_ca_list(single_ca)","def server_auth_ca_ids(self, server_auth_ca_ids):\n\n self._server_auth_ca_ids = server_auth_ca_ids","def certificate(self, certificate):\n\n self._certificate = certificate","def ca_cert_path(self) -> str:\n return self._ca_cert_path","def org_apache_felix_https_clientcertificate(self, org_apache_felix_https_clientcertificate: ConfigNodePropertyDropDown):\n\n self._org_apache_felix_https_clientcertificate = org_apache_felix_https_clientcertificate","def test_set_after_add_client_ca(self):\n cacert = load_certificate(FILETYPE_PEM, root_cert_pem)\n secert = load_certificate(FILETYPE_PEM, server_cert_pem)\n clcert = load_certificate(FILETYPE_PEM, server_cert_pem)\n\n cadesc = cacert.get_subject()\n sedesc = secert.get_subject()\n\n def set_replaces_add_ca(ctx):\n ctx.add_client_ca(clcert)\n ctx.set_client_ca_list([cadesc])\n ctx.add_client_ca(secert)\n return [cadesc, sedesc]\n\n self._check_client_ca_list(set_replaces_add_ca)","def install_ca():\n require_root()\n\n config.proxy.install_ca_cert()\n log.info('OK')","def client_cert(self, client_cert):\n\n self._client_cert = client_cert","def AddCaCertificateFlag(parser, required=False):\n help_text = \"\"\"\\\n x509 PEM-encoded certificate of the CA that signed the database\n server's certificate. The replica will use this certificate to verify\n it's connecting to the correct host. Database Migration Service encrypts the\n value when storing it.\n \"\"\"\n parser.add_argument('--ca-certificate', help=help_text, required=required)","def test_set_and_add_client_ca(self):\n cacert = load_certificate(FILETYPE_PEM, root_cert_pem)\n secert = load_certificate(FILETYPE_PEM, server_cert_pem)\n clcert = load_certificate(FILETYPE_PEM, server_cert_pem)\n\n cadesc = cacert.get_subject()\n sedesc = secert.get_subject()\n cldesc = clcert.get_subject()\n\n def mixed_set_add_ca(ctx):\n ctx.set_client_ca_list([cadesc, sedesc])\n ctx.add_client_ca(clcert)\n return [cadesc, sedesc, cldesc]\n\n self._check_client_ca_list(mixed_set_add_ca)","def _check_ca_certificate(self):\n if not os.path.exists(self._ca_certificate_path):\n with open(self._ca_certificate_path, \"w\") as f:\n f.write(ssl.get_server_certificate((\"127.0.0.1\", self._app_port), ssl_version=ssl.PROTOCOL_TLSv1_2))","def initca(ca_dir):\n click.echo('Initiliasing new CA in %s' % ca_dir)\n sca = SimpleCA(ca_dir)\n try:\n sca.init_ca()\n except FileExistsError as err:\n click.echo('The CA directory (%s) exists, not doing anything' %\n err.filename)\n exit(1)","def server_root_ca_certificate(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"server_root_ca_certificate\")","def test_reset_ca_list(self):\n cacert = load_certificate(FILETYPE_PEM, root_cert_pem)\n secert = load_certificate(FILETYPE_PEM, server_cert_pem)\n clcert = load_certificate(FILETYPE_PEM, server_cert_pem)\n\n cadesc = cacert.get_subject()\n sedesc = secert.get_subject()\n cldesc = clcert.get_subject()\n\n def changed_ca(ctx):\n ctx.set_client_ca_list([sedesc, cldesc])\n ctx.set_client_ca_list([cadesc])\n return [cadesc]\n\n self._check_client_ca_list(changed_ca)","def gen_ca():\n require_root()\n\n config.proxy.gen_ca_certs()\n log.info('OK')","def ca(self):\n\n return self._basic_constraints['ca'].native","def insert_ca_certs_into_systemwide_ca_store(self, ca_certs):\n\n raise NotImplementedError()","def get_ssl_ca_settings():\n ca_data = {}\n https_service_endpoints = config('https-service-endpoints')\n if (https_service_endpoints and\n bool_from_string(https_service_endpoints)):\n # Pass CA cert as client will need it to\n # verify https connections\n ca = get_ca(user=SSH_USER)\n ca_bundle = ca.get_ca_bundle()\n ca_data['https_keystone'] = 'True'\n ca_data['ca_cert'] = b64encode(ca_bundle)\n return ca_data","def ssl(self, cainfo=None, verify=True, cert=None, key=None):\n if cainfo:\n self.curl.setopt(pycurl.CAINFO, cainfo)\n\n if verify == False:\n self.curl.setopt(pycurl.SSL_VERIFYPEER, 0)\n self.curl.setopt(pycurl.SSL_VERIFYHOST, 0)\n else:\n self.curl.setopt(pycurl.SSL_VERIFYPEER, 1)\n self.curl.setopt(pycurl.SSL_VERIFYHOST, 2)\n if cert:\n #self.curl.setopt(pycurl.SSLCERTTYPE, \"DER\")\n self.curl.setopt(pycurl.SSLCERT, cert)\n if key:\n self.curl.setopt(pycurl.SSLKEY, key)","def test_load_client_ca(self, context, ca_file):\n context.load_client_ca(ca_file)","def tobacco(self, tobacco):\n\n self.logger.debug(\"In 'tobacco' setter.\")\n\n self._tobacco = tobacco","def test_one_add_client_ca(self):\n cacert = load_certificate(FILETYPE_PEM, root_cert_pem)\n cadesc = cacert.get_subject()\n\n def single_ca(ctx):\n ctx.add_client_ca(cacert)\n return [cadesc]\n\n self._check_client_ca_list(single_ca)","def _load_verify_cafile(self, cafile):\n with open(cafile, \"w\") as fObj:\n fObj.write(root_cert_pem.decode(\"ascii\"))\n\n self._load_verify_locations_test(cafile)","def developer_certificate_identity(self, developer_certificate_identity):\n\n self._developer_certificate_identity = developer_certificate_identity","def client_certificate_id(self, client_certificate_id):\n\n self._client_certificate_id = client_certificate_id","def set_ssl_context(self, ssl_verify, ssl_cafile):\n if not ssl_verify:\n self.ssl_context = ssl.create_default_context()\n self.ssl_context.check_hostname = False\n self.ssl_context.verify_mode = ssl.CERT_NONE\n elif ssl_cafile:\n self.ssl_context = ssl.create_default_context(cafile=ssl_cafile)\n else:\n self.ssl_context = ssl.create_default_context()","def dcos_ca_bundle():\n resp = sdk_cmd.cluster_request('GET', '/ca/dcos-ca.crt')\n cert = resp.content.decode('ascii')\n assert cert is not None\n return cert","def setCertfile(self, certfile):\r\n if not os.access(certfile, os.R_OK):\r\n raise IOError('No such certfile found: %s' % (certfile))\r\n self.certfile = certfile","def client_x509_cert_url(self, client_x509_cert_url):\n\n self._client_x509_cert_url = client_x509_cert_url","def token_cert(self, token_cert):\n\n self._token_cert = token_cert","def test_set_multiple_ca_list(self):\n secert = load_certificate(FILETYPE_PEM, server_cert_pem)\n clcert = load_certificate(FILETYPE_PEM, server_cert_pem)\n\n sedesc = secert.get_subject()\n cldesc = clcert.get_subject()\n\n def multiple_ca(ctx):\n L = [sedesc, cldesc]\n ctx.set_client_ca_list(L)\n return L\n\n self._check_client_ca_list(multiple_ca)","def init_ca(self):\n self._init_dir()\n self._init_serial()\n self._init_keys()","def certificate_issuer_id(self, certificate_issuer_id):\n\n self._certificate_issuer_id = certificate_issuer_id","def ca_bundle(self) -> Optional[str]:\n return pulumi.get(self, \"ca_bundle\")","def ca_bundle(self) -> Optional[str]:\n return pulumi.get(self, \"ca_bundle\")","def test_multiple_add_client_ca(self):\n cacert = load_certificate(FILETYPE_PEM, root_cert_pem)\n secert = load_certificate(FILETYPE_PEM, server_cert_pem)\n\n cadesc = cacert.get_subject()\n sedesc = secert.get_subject()\n\n def multiple_ca(ctx):\n ctx.add_client_ca(cacert)\n ctx.add_client_ca(secert)\n return [cadesc, sedesc]\n\n self._check_client_ca_list(multiple_ca)","def create_CA(dn):\n cmd_genrsa = [\"openssl\",\n \"genrsa\",\n \"-aes256\",\n \"-out\", f'{pki_dir}/ca.key',\n \"-passout\", f'pass:{ca_password}',\n f'{rsa_keysize}']\n cmd_req = [\"openssl\",\n \"req\",\n \"-new\",\n \"-x509\",\n \"-days\", \"999999\",\n \"-sha256\",\n \"-key\", f'{pki_dir}/ca.key',\n \"-out\", server_key_files[\"ca\"],\n \"-subj\", f'{dn}',\n \"-passin\", f'pass:{ca_password}']\n cmds = [cmd_genrsa, cmd_req]\n for cmd in cmds:\n exec_cmd(cmd)","def tls_ca_certificate_pem_path(ca):\n with ca.cert_pem.tempfile() as ca_cert_pem:\n yield ca_cert_pem","def endpoint_tls_ca(self) -> Optional[bytes]:\n if self.is_ready and (data := self._data):\n if data.endpoint_tls_ca:\n return data.endpoint_tls_ca.encode()\n return None","def ssl_ca_location(self):\n if \"ssl.ca.location\" not in self._config:\n return None\n return self._config[\"ssl.ca.location\"]","def test_mutated_ca_list(self):\n cacert = load_certificate(FILETYPE_PEM, root_cert_pem)\n secert = load_certificate(FILETYPE_PEM, server_cert_pem)\n\n cadesc = cacert.get_subject()\n sedesc = secert.get_subject()\n\n def mutated_ca(ctx):\n L = [cadesc]\n ctx.set_client_ca_list([cadesc])\n L.append(sedesc)\n return [cadesc]\n\n self._check_client_ca_list(mutated_ca)","def cci(self, cci: float):\n\n self._cci = cci","def remove_ca_certs_from_systemwide_ca_store(self):\n\n raise NotImplementedError()","def set_certificate(\n self, path: Union[bytes, str], certificate: Optional[Union[bytes, str]] = None\n ) -> None:\n path = _to_bytes_or_null(path)\n certificate = _to_bytes_or_null(certificate)\n ret = lib.Fapi_SetCertificate(self._ctx, path, certificate)\n _chkrc(ret)","def principal_city(self, principal_city):\n\n self._principal_city = principal_city","def ca(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"ca\")","def ca(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"ca\")","def ca(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"ca\")","def set_cname(self, cname):\n self.__cname = cname","def ca_cert_resource_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"ca_cert_resource_id\")","def ca_cert_resource_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"ca_cert_resource_id\")","def ca_cert_resource_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"ca_cert_resource_id\")","def setCbsdRecords(self, records):\n self._dump_data['cbsd'] = records","def test_load_client_ca_unicode(self, context, ca_file):\n pytest.deprecated_call(context.load_client_ca, ca_file.decode(\"ascii\"))","def setACSLabel(self, label):\n\n if self._n_csets:\n if label is None or isinstance(label, str):\n self._cslabels[self._acsi] = label\n else:\n raise TypeError('label must be a string')","def fusion_api_import_external_ca_certificates(self, body, api=None, headers=None):\n return self.ca.add(body, api=api, headers=headers)","def causative_agent(self, causative_agent):\n if causative_agent is None:\n raise ValueError(\"Invalid value for `causative_agent`, must not be `None`\") # noqa: E501\n\n self._causative_agent = causative_agent","def __check_opts(self):\n self.ca_cert_file = os.environ['HOME'] + '/.cat_installer/ca.pem'\n self.pfx_file = os.environ['HOME'] + '/.cat_installer/user.p12'\n if not os.path.isfile(self.ca_cert_file):\n print(Messages.cert_error)\n sys.exit(2)","def ca_bundle(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"ca_bundle\")","def catalog_id(self, catalog_id):\n self._catalog_id = catalog_id","def is_ca_cert(cert):\n # extract \"ca\" value from cert extensions\n is_ca = False\n try:\n basic_constraints = cert.extensions.get_extension_for_oid(\n x509.ExtensionOID.BASIC_CONSTRAINTS)\n value = getattr(basic_constraints, 'value', None)\n if value:\n is_ca = getattr(value, 'ca', False)\n except x509.ExtensionNotFound:\n LOG.debug(\"The cert doesn't have BASIC_CONSTRAINTS extension\")\n pass\n return is_ca","def auth_provider_x509_cert_url(self, auth_provider_x509_cert_url):\n\n self._auth_provider_x509_cert_url = auth_provider_x509_cert_url","def __init__(self, ca, cert_type):\n self.ca = ca # required\n self.nonce = None # optional, has default = os.urandom(32)\n self.public_key_comment = None\n self.serial = None # can be set, has default = 0\n self.cert_type = None # required: User = 1, Host = 2\n self.key_id = None # optional, default = ''\n self.valid_principals = list() # optional, default = ''\n self.valid_after = None # optional, default = 0\n self.valid_before = None # optional, default = 2^64-1\n self.critical_option_force_command = None # optional, default = ''\n self.critical_option_source_address = None # optional, default = ''\n self.extensions = None # optional, default = ''\n self.reserved = '' # should always be this value\n self.signature = None\n self.signed_cert = None\n self.public_key_comment = None\n self.cert_type = cert_type","def handle_cacert(self):\n\n file = open(\"./certs/cacert.p7b\", \"r\")\n ca_certs = file.read()\n\n self.set_est_rsp_header(len(ca_certs))\n\n self.wfile.write(ca_certs.encode('utf-8'))","def fusion_api_get_ca_certificate(self, uri=None, api=None, headers=None, param=''):\n return self.ca.get(uri=uri, api=api, headers=headers, param=param)","def ssl_certificate(self, ssl_certificate):\n if ssl_certificate is None:\n raise ValueError(\"Invalid value for `ssl_certificate`, must not be `None`\") # noqa: E501\n\n self._ssl_certificate = ssl_certificate","def center(self, center):\n if self.local_vars_configuration.client_side_validation and center is None: # noqa: E501\n raise ValueError(\"Invalid value for `center`, must not be `None`\") # noqa: E501\n\n self._center = center","def set_cli_author(click_context) -> None:\n config = get_or_create_cli_config()\n cli_author = config.get(AUTHOR_KEY, None)\n if cli_author is None:\n raise click.ClickException(\n \"The AEA configurations are not initialized. Use `aea init` before continuing.\"\n )\n click_context.obj.set_config(\"cli_author\", cli_author)","def cfa(self, cfa):\n\n self._cfa = cfa","def __init__(__self__, *,\n auth_type: pulumi.Input[str],\n ca_cert_resource_id: Optional[pulumi.Input[str]] = None):\n pulumi.set(__self__, \"auth_type\", 'Public')\n if ca_cert_resource_id is not None:\n pulumi.set(__self__, \"ca_cert_resource_id\", ca_cert_resource_id)","def conan_channel(self, conan_channel):\n\n self._conan_channel = conan_channel","def initial_setup():\n\n if os.path.exists(cfg.ca_private_key_path()):\n pkey = _try_load_ca_private_key(cfg.ca_private_key_path())\n else:\n pkey = _generate_ca_private_key(cfg.ca_private_key_path())\n\n if os.path.exists(cfg.ca_cert_path()):\n _try_load_ca_cert(cfg.ca_cert_path())\n else:\n _generate_ca_cert(cfg.ca_cert_path(), pkey)","def ata_security(self, ata_security: SmartSsdAtaSecurity):\n\n self._ata_security = ata_security","def svn_client_ctx_t_auth_baton_set(svn_client_ctx_t_self, svn_auth_baton_t_auth_baton): # real signature unknown; restored from __doc__\n pass","def __init__(__self__, *,\n client_certificate_config: Optional[pulumi.Input['ClientCertificateConfigArgs']] = None,\n cluster_ca_certificate: Optional[pulumi.Input[str]] = None,\n password: Optional[pulumi.Input[str]] = None,\n username: Optional[pulumi.Input[str]] = None):\n if client_certificate_config is not None:\n pulumi.set(__self__, \"client_certificate_config\", client_certificate_config)\n if cluster_ca_certificate is not None:\n pulumi.set(__self__, \"cluster_ca_certificate\", cluster_ca_certificate)\n if password is not None:\n pulumi.set(__self__, \"password\", password)\n if username is not None:\n pulumi.set(__self__, \"username\", username)","def set_console_font(font):\n log.debug(\"setting console font to %s\", font)\n rc = execWithRedirect(\"setfont\", [font])\n if rc == 0:\n log.debug(\"console font set successfully to %s\", font)\n return True\n else:\n log.error(\"setting console font to %s failed\", font)\n return False","def trusted_ca(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"trusted_ca\")","def trusted_ca(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"trusted_ca\")","def load_cert_chain(self, certfile, keyfile: Optional[Any] = ...):\n ...","def center(self, center):\n\n self._center = center","def campaign(self, campaign):\n\n self._campaign = campaign","def tls_certificate(ca):\n interface, _host, _port = _get_conn_data(ANY_INTERFACE_IPV4)\n return ca.issue_cert(ntou(interface))","def __init__(__self__, *,\n ca_bundle: Optional[pulumi.Input[str]] = None,\n url: Optional[pulumi.Input[str]] = None):\n if ca_bundle is not None:\n pulumi.set(__self__, \"ca_bundle\", ca_bundle)\n if url is not None:\n pulumi.set(__self__, \"url\", url)","def __init__(__self__, *,\n certificate_id: pulumi.Input[str]):\n pulumi.set(__self__, \"certificate_id\", certificate_id)","def ca():\n return trustme.CA()","def set_vCa(self, in_ca: float) -> None:\n r: float = self.ion_params.r\n t: float = self.ion_params.t\n f: float = self.ion_params.f\n ex_ca: float = self.concentration['ex_na']\n vCa: float = r * t / (f * 2) * np.log(ex_ca / in_ca) * 1000\n self.cav.set_e(new_e=vCa)","def sequencing_center(self, sequencing_center):\n self.logger.debug(\"In 'sequencing_center' setter.\")\n\n self._sequencing_center = sequencing_center","def set(self, shell=None):\n\n # iterate over the env variable objects and set them in the env\n for var in self._vars.itervalues():\n var.set(shell=shell)","def cname(self, cname):\n if (\n self.local_vars_configuration.client_side_validation and cname is None\n ): # noqa: E501\n raise ValueError(\n \"Invalid value for `cname`, must not be `None`\"\n ) # noqa: E501\n\n self._cname = cname","def ca_file(tmpdir):\n key = rsa.generate_private_key(public_exponent=65537, key_size=2048)\n public_key = key.public_key()\n\n builder = x509.CertificateBuilder()\n builder = builder.subject_name(\n x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, \"pyopenssl.org\")])\n )\n builder = builder.issuer_name(\n x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, \"pyopenssl.org\")])\n )\n one_day = datetime.timedelta(1, 0, 0)\n builder = builder.not_valid_before(datetime.datetime.today() - one_day)\n builder = builder.not_valid_after(datetime.datetime.today() + one_day)\n builder = builder.serial_number(int(uuid.uuid4()))\n builder = builder.public_key(public_key)\n builder = builder.add_extension(\n x509.BasicConstraints(ca=True, path_length=None),\n critical=True,\n )\n\n certificate = builder.sign(private_key=key, algorithm=hashes.SHA256())\n\n ca_file = tmpdir.join(\"test.pem\")\n ca_file.write_binary(\n certificate.public_bytes(\n encoding=serialization.Encoding.PEM,\n )\n )\n\n return str(ca_file).encode(\"ascii\")","def principal(self, principal):\n\n self._principal = principal","def configure_tomcat_to_load_jacoco_agent(self):\n open(\"/tmp/jacoco.conf\", \"w\").write('JAVA_OPTS=\"$JAVA_OPTS -javaagent:/tmp/jacoco-agent.jar=destfile=/tmp/jacoco-it.exec\"\\n')\n zone = self.config['zones'][0]['name']\n for host in self.config['mgtSvr']:\n connection = {'hostname': host['mgtSvrIp'], 'username': host['user'], 'password': host['passwd']}\n self.zone = zone\n src_file = self.workspace + \"/target/jacoco-agent.jar\"\n self._scp_put(srcfile=src_file, destfile=\"/tmp\", **connection)\n self._scp_put(srcfile=\"/tmp/jacoco.conf\", destfile=\"/etc/tomcat/conf.d/jacoco.conf\", **connection)\n print(\"==> Tomcat configured\")\n os.unlink(\"/tmp/jacoco.conf\")"],"string":"[\n \"def ca_cert(self, ca_cert):\\n\\n self._ca_cert = ca_cert\",\n \"def console_custom_cert(self, console_custom_cert):\\n\\n self._console_custom_cert = console_custom_cert\",\n \"def ca_cert_path(self, ca_cert_path: str):\\n\\n self._ca_cert_path = ca_cert_path\",\n \"def save_ca():\\n cert_file = os.environ.get('HOME') + '/.cat_installer/ca.pem'\\n debug(\\\"saving cert\\\")\\n with open(cert_file, 'w') as cert:\\n cert.write(Config.CA + \\\"\\\\n\\\")\",\n \"def cert(self, value):\\n self._cert = value\",\n \"def ca_certificate(self) -> str:\\n return pulumi.get(self, \\\"ca_certificate\\\")\",\n \"def ca_certificate(self) -> str:\\n return pulumi.get(self, \\\"ca_certificate\\\")\",\n \"def ca_certificate(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"ca_certificate\\\")\",\n \"def test_set_one_ca_list(self):\\n cacert = load_certificate(FILETYPE_PEM, root_cert_pem)\\n cadesc = cacert.get_subject()\\n\\n def single_ca(ctx):\\n ctx.set_client_ca_list([cadesc])\\n return [cadesc]\\n\\n self._check_client_ca_list(single_ca)\",\n \"def server_auth_ca_ids(self, server_auth_ca_ids):\\n\\n self._server_auth_ca_ids = server_auth_ca_ids\",\n \"def certificate(self, certificate):\\n\\n self._certificate = certificate\",\n \"def ca_cert_path(self) -> str:\\n return self._ca_cert_path\",\n \"def org_apache_felix_https_clientcertificate(self, org_apache_felix_https_clientcertificate: ConfigNodePropertyDropDown):\\n\\n self._org_apache_felix_https_clientcertificate = org_apache_felix_https_clientcertificate\",\n \"def test_set_after_add_client_ca(self):\\n cacert = load_certificate(FILETYPE_PEM, root_cert_pem)\\n secert = load_certificate(FILETYPE_PEM, server_cert_pem)\\n clcert = load_certificate(FILETYPE_PEM, server_cert_pem)\\n\\n cadesc = cacert.get_subject()\\n sedesc = secert.get_subject()\\n\\n def set_replaces_add_ca(ctx):\\n ctx.add_client_ca(clcert)\\n ctx.set_client_ca_list([cadesc])\\n ctx.add_client_ca(secert)\\n return [cadesc, sedesc]\\n\\n self._check_client_ca_list(set_replaces_add_ca)\",\n \"def install_ca():\\n require_root()\\n\\n config.proxy.install_ca_cert()\\n log.info('OK')\",\n \"def client_cert(self, client_cert):\\n\\n self._client_cert = client_cert\",\n \"def AddCaCertificateFlag(parser, required=False):\\n help_text = \\\"\\\"\\\"\\\\\\n x509 PEM-encoded certificate of the CA that signed the database\\n server's certificate. The replica will use this certificate to verify\\n it's connecting to the correct host. Database Migration Service encrypts the\\n value when storing it.\\n \\\"\\\"\\\"\\n parser.add_argument('--ca-certificate', help=help_text, required=required)\",\n \"def test_set_and_add_client_ca(self):\\n cacert = load_certificate(FILETYPE_PEM, root_cert_pem)\\n secert = load_certificate(FILETYPE_PEM, server_cert_pem)\\n clcert = load_certificate(FILETYPE_PEM, server_cert_pem)\\n\\n cadesc = cacert.get_subject()\\n sedesc = secert.get_subject()\\n cldesc = clcert.get_subject()\\n\\n def mixed_set_add_ca(ctx):\\n ctx.set_client_ca_list([cadesc, sedesc])\\n ctx.add_client_ca(clcert)\\n return [cadesc, sedesc, cldesc]\\n\\n self._check_client_ca_list(mixed_set_add_ca)\",\n \"def _check_ca_certificate(self):\\n if not os.path.exists(self._ca_certificate_path):\\n with open(self._ca_certificate_path, \\\"w\\\") as f:\\n f.write(ssl.get_server_certificate((\\\"127.0.0.1\\\", self._app_port), ssl_version=ssl.PROTOCOL_TLSv1_2))\",\n \"def initca(ca_dir):\\n click.echo('Initiliasing new CA in %s' % ca_dir)\\n sca = SimpleCA(ca_dir)\\n try:\\n sca.init_ca()\\n except FileExistsError as err:\\n click.echo('The CA directory (%s) exists, not doing anything' %\\n err.filename)\\n exit(1)\",\n \"def server_root_ca_certificate(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"server_root_ca_certificate\\\")\",\n \"def test_reset_ca_list(self):\\n cacert = load_certificate(FILETYPE_PEM, root_cert_pem)\\n secert = load_certificate(FILETYPE_PEM, server_cert_pem)\\n clcert = load_certificate(FILETYPE_PEM, server_cert_pem)\\n\\n cadesc = cacert.get_subject()\\n sedesc = secert.get_subject()\\n cldesc = clcert.get_subject()\\n\\n def changed_ca(ctx):\\n ctx.set_client_ca_list([sedesc, cldesc])\\n ctx.set_client_ca_list([cadesc])\\n return [cadesc]\\n\\n self._check_client_ca_list(changed_ca)\",\n \"def gen_ca():\\n require_root()\\n\\n config.proxy.gen_ca_certs()\\n log.info('OK')\",\n \"def ca(self):\\n\\n return self._basic_constraints['ca'].native\",\n \"def insert_ca_certs_into_systemwide_ca_store(self, ca_certs):\\n\\n raise NotImplementedError()\",\n \"def get_ssl_ca_settings():\\n ca_data = {}\\n https_service_endpoints = config('https-service-endpoints')\\n if (https_service_endpoints and\\n bool_from_string(https_service_endpoints)):\\n # Pass CA cert as client will need it to\\n # verify https connections\\n ca = get_ca(user=SSH_USER)\\n ca_bundle = ca.get_ca_bundle()\\n ca_data['https_keystone'] = 'True'\\n ca_data['ca_cert'] = b64encode(ca_bundle)\\n return ca_data\",\n \"def ssl(self, cainfo=None, verify=True, cert=None, key=None):\\n if cainfo:\\n self.curl.setopt(pycurl.CAINFO, cainfo)\\n\\n if verify == False:\\n self.curl.setopt(pycurl.SSL_VERIFYPEER, 0)\\n self.curl.setopt(pycurl.SSL_VERIFYHOST, 0)\\n else:\\n self.curl.setopt(pycurl.SSL_VERIFYPEER, 1)\\n self.curl.setopt(pycurl.SSL_VERIFYHOST, 2)\\n if cert:\\n #self.curl.setopt(pycurl.SSLCERTTYPE, \\\"DER\\\")\\n self.curl.setopt(pycurl.SSLCERT, cert)\\n if key:\\n self.curl.setopt(pycurl.SSLKEY, key)\",\n \"def test_load_client_ca(self, context, ca_file):\\n context.load_client_ca(ca_file)\",\n \"def tobacco(self, tobacco):\\n\\n self.logger.debug(\\\"In 'tobacco' setter.\\\")\\n\\n self._tobacco = tobacco\",\n \"def test_one_add_client_ca(self):\\n cacert = load_certificate(FILETYPE_PEM, root_cert_pem)\\n cadesc = cacert.get_subject()\\n\\n def single_ca(ctx):\\n ctx.add_client_ca(cacert)\\n return [cadesc]\\n\\n self._check_client_ca_list(single_ca)\",\n \"def _load_verify_cafile(self, cafile):\\n with open(cafile, \\\"w\\\") as fObj:\\n fObj.write(root_cert_pem.decode(\\\"ascii\\\"))\\n\\n self._load_verify_locations_test(cafile)\",\n \"def developer_certificate_identity(self, developer_certificate_identity):\\n\\n self._developer_certificate_identity = developer_certificate_identity\",\n \"def client_certificate_id(self, client_certificate_id):\\n\\n self._client_certificate_id = client_certificate_id\",\n \"def set_ssl_context(self, ssl_verify, ssl_cafile):\\n if not ssl_verify:\\n self.ssl_context = ssl.create_default_context()\\n self.ssl_context.check_hostname = False\\n self.ssl_context.verify_mode = ssl.CERT_NONE\\n elif ssl_cafile:\\n self.ssl_context = ssl.create_default_context(cafile=ssl_cafile)\\n else:\\n self.ssl_context = ssl.create_default_context()\",\n \"def dcos_ca_bundle():\\n resp = sdk_cmd.cluster_request('GET', '/ca/dcos-ca.crt')\\n cert = resp.content.decode('ascii')\\n assert cert is not None\\n return cert\",\n \"def setCertfile(self, certfile):\\r\\n if not os.access(certfile, os.R_OK):\\r\\n raise IOError('No such certfile found: %s' % (certfile))\\r\\n self.certfile = certfile\",\n \"def client_x509_cert_url(self, client_x509_cert_url):\\n\\n self._client_x509_cert_url = client_x509_cert_url\",\n \"def token_cert(self, token_cert):\\n\\n self._token_cert = token_cert\",\n \"def test_set_multiple_ca_list(self):\\n secert = load_certificate(FILETYPE_PEM, server_cert_pem)\\n clcert = load_certificate(FILETYPE_PEM, server_cert_pem)\\n\\n sedesc = secert.get_subject()\\n cldesc = clcert.get_subject()\\n\\n def multiple_ca(ctx):\\n L = [sedesc, cldesc]\\n ctx.set_client_ca_list(L)\\n return L\\n\\n self._check_client_ca_list(multiple_ca)\",\n \"def init_ca(self):\\n self._init_dir()\\n self._init_serial()\\n self._init_keys()\",\n \"def certificate_issuer_id(self, certificate_issuer_id):\\n\\n self._certificate_issuer_id = certificate_issuer_id\",\n \"def ca_bundle(self) -> Optional[str]:\\n return pulumi.get(self, \\\"ca_bundle\\\")\",\n \"def ca_bundle(self) -> Optional[str]:\\n return pulumi.get(self, \\\"ca_bundle\\\")\",\n \"def test_multiple_add_client_ca(self):\\n cacert = load_certificate(FILETYPE_PEM, root_cert_pem)\\n secert = load_certificate(FILETYPE_PEM, server_cert_pem)\\n\\n cadesc = cacert.get_subject()\\n sedesc = secert.get_subject()\\n\\n def multiple_ca(ctx):\\n ctx.add_client_ca(cacert)\\n ctx.add_client_ca(secert)\\n return [cadesc, sedesc]\\n\\n self._check_client_ca_list(multiple_ca)\",\n \"def create_CA(dn):\\n cmd_genrsa = [\\\"openssl\\\",\\n \\\"genrsa\\\",\\n \\\"-aes256\\\",\\n \\\"-out\\\", f'{pki_dir}/ca.key',\\n \\\"-passout\\\", f'pass:{ca_password}',\\n f'{rsa_keysize}']\\n cmd_req = [\\\"openssl\\\",\\n \\\"req\\\",\\n \\\"-new\\\",\\n \\\"-x509\\\",\\n \\\"-days\\\", \\\"999999\\\",\\n \\\"-sha256\\\",\\n \\\"-key\\\", f'{pki_dir}/ca.key',\\n \\\"-out\\\", server_key_files[\\\"ca\\\"],\\n \\\"-subj\\\", f'{dn}',\\n \\\"-passin\\\", f'pass:{ca_password}']\\n cmds = [cmd_genrsa, cmd_req]\\n for cmd in cmds:\\n exec_cmd(cmd)\",\n \"def tls_ca_certificate_pem_path(ca):\\n with ca.cert_pem.tempfile() as ca_cert_pem:\\n yield ca_cert_pem\",\n \"def endpoint_tls_ca(self) -> Optional[bytes]:\\n if self.is_ready and (data := self._data):\\n if data.endpoint_tls_ca:\\n return data.endpoint_tls_ca.encode()\\n return None\",\n \"def ssl_ca_location(self):\\n if \\\"ssl.ca.location\\\" not in self._config:\\n return None\\n return self._config[\\\"ssl.ca.location\\\"]\",\n \"def test_mutated_ca_list(self):\\n cacert = load_certificate(FILETYPE_PEM, root_cert_pem)\\n secert = load_certificate(FILETYPE_PEM, server_cert_pem)\\n\\n cadesc = cacert.get_subject()\\n sedesc = secert.get_subject()\\n\\n def mutated_ca(ctx):\\n L = [cadesc]\\n ctx.set_client_ca_list([cadesc])\\n L.append(sedesc)\\n return [cadesc]\\n\\n self._check_client_ca_list(mutated_ca)\",\n \"def cci(self, cci: float):\\n\\n self._cci = cci\",\n \"def remove_ca_certs_from_systemwide_ca_store(self):\\n\\n raise NotImplementedError()\",\n \"def set_certificate(\\n self, path: Union[bytes, str], certificate: Optional[Union[bytes, str]] = None\\n ) -> None:\\n path = _to_bytes_or_null(path)\\n certificate = _to_bytes_or_null(certificate)\\n ret = lib.Fapi_SetCertificate(self._ctx, path, certificate)\\n _chkrc(ret)\",\n \"def principal_city(self, principal_city):\\n\\n self._principal_city = principal_city\",\n \"def ca(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"ca\\\")\",\n \"def ca(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"ca\\\")\",\n \"def ca(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"ca\\\")\",\n \"def set_cname(self, cname):\\n self.__cname = cname\",\n \"def ca_cert_resource_id(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"ca_cert_resource_id\\\")\",\n \"def ca_cert_resource_id(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"ca_cert_resource_id\\\")\",\n \"def ca_cert_resource_id(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"ca_cert_resource_id\\\")\",\n \"def setCbsdRecords(self, records):\\n self._dump_data['cbsd'] = records\",\n \"def test_load_client_ca_unicode(self, context, ca_file):\\n pytest.deprecated_call(context.load_client_ca, ca_file.decode(\\\"ascii\\\"))\",\n \"def setACSLabel(self, label):\\n\\n if self._n_csets:\\n if label is None or isinstance(label, str):\\n self._cslabels[self._acsi] = label\\n else:\\n raise TypeError('label must be a string')\",\n \"def fusion_api_import_external_ca_certificates(self, body, api=None, headers=None):\\n return self.ca.add(body, api=api, headers=headers)\",\n \"def causative_agent(self, causative_agent):\\n if causative_agent is None:\\n raise ValueError(\\\"Invalid value for `causative_agent`, must not be `None`\\\") # noqa: E501\\n\\n self._causative_agent = causative_agent\",\n \"def __check_opts(self):\\n self.ca_cert_file = os.environ['HOME'] + '/.cat_installer/ca.pem'\\n self.pfx_file = os.environ['HOME'] + '/.cat_installer/user.p12'\\n if not os.path.isfile(self.ca_cert_file):\\n print(Messages.cert_error)\\n sys.exit(2)\",\n \"def ca_bundle(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"ca_bundle\\\")\",\n \"def catalog_id(self, catalog_id):\\n self._catalog_id = catalog_id\",\n \"def is_ca_cert(cert):\\n # extract \\\"ca\\\" value from cert extensions\\n is_ca = False\\n try:\\n basic_constraints = cert.extensions.get_extension_for_oid(\\n x509.ExtensionOID.BASIC_CONSTRAINTS)\\n value = getattr(basic_constraints, 'value', None)\\n if value:\\n is_ca = getattr(value, 'ca', False)\\n except x509.ExtensionNotFound:\\n LOG.debug(\\\"The cert doesn't have BASIC_CONSTRAINTS extension\\\")\\n pass\\n return is_ca\",\n \"def auth_provider_x509_cert_url(self, auth_provider_x509_cert_url):\\n\\n self._auth_provider_x509_cert_url = auth_provider_x509_cert_url\",\n \"def __init__(self, ca, cert_type):\\n self.ca = ca # required\\n self.nonce = None # optional, has default = os.urandom(32)\\n self.public_key_comment = None\\n self.serial = None # can be set, has default = 0\\n self.cert_type = None # required: User = 1, Host = 2\\n self.key_id = None # optional, default = ''\\n self.valid_principals = list() # optional, default = ''\\n self.valid_after = None # optional, default = 0\\n self.valid_before = None # optional, default = 2^64-1\\n self.critical_option_force_command = None # optional, default = ''\\n self.critical_option_source_address = None # optional, default = ''\\n self.extensions = None # optional, default = ''\\n self.reserved = '' # should always be this value\\n self.signature = None\\n self.signed_cert = None\\n self.public_key_comment = None\\n self.cert_type = cert_type\",\n \"def handle_cacert(self):\\n\\n file = open(\\\"./certs/cacert.p7b\\\", \\\"r\\\")\\n ca_certs = file.read()\\n\\n self.set_est_rsp_header(len(ca_certs))\\n\\n self.wfile.write(ca_certs.encode('utf-8'))\",\n \"def fusion_api_get_ca_certificate(self, uri=None, api=None, headers=None, param=''):\\n return self.ca.get(uri=uri, api=api, headers=headers, param=param)\",\n \"def ssl_certificate(self, ssl_certificate):\\n if ssl_certificate is None:\\n raise ValueError(\\\"Invalid value for `ssl_certificate`, must not be `None`\\\") # noqa: E501\\n\\n self._ssl_certificate = ssl_certificate\",\n \"def center(self, center):\\n if self.local_vars_configuration.client_side_validation and center is None: # noqa: E501\\n raise ValueError(\\\"Invalid value for `center`, must not be `None`\\\") # noqa: E501\\n\\n self._center = center\",\n \"def set_cli_author(click_context) -> None:\\n config = get_or_create_cli_config()\\n cli_author = config.get(AUTHOR_KEY, None)\\n if cli_author is None:\\n raise click.ClickException(\\n \\\"The AEA configurations are not initialized. Use `aea init` before continuing.\\\"\\n )\\n click_context.obj.set_config(\\\"cli_author\\\", cli_author)\",\n \"def cfa(self, cfa):\\n\\n self._cfa = cfa\",\n \"def __init__(__self__, *,\\n auth_type: pulumi.Input[str],\\n ca_cert_resource_id: Optional[pulumi.Input[str]] = None):\\n pulumi.set(__self__, \\\"auth_type\\\", 'Public')\\n if ca_cert_resource_id is not None:\\n pulumi.set(__self__, \\\"ca_cert_resource_id\\\", ca_cert_resource_id)\",\n \"def conan_channel(self, conan_channel):\\n\\n self._conan_channel = conan_channel\",\n \"def initial_setup():\\n\\n if os.path.exists(cfg.ca_private_key_path()):\\n pkey = _try_load_ca_private_key(cfg.ca_private_key_path())\\n else:\\n pkey = _generate_ca_private_key(cfg.ca_private_key_path())\\n\\n if os.path.exists(cfg.ca_cert_path()):\\n _try_load_ca_cert(cfg.ca_cert_path())\\n else:\\n _generate_ca_cert(cfg.ca_cert_path(), pkey)\",\n \"def ata_security(self, ata_security: SmartSsdAtaSecurity):\\n\\n self._ata_security = ata_security\",\n \"def svn_client_ctx_t_auth_baton_set(svn_client_ctx_t_self, svn_auth_baton_t_auth_baton): # real signature unknown; restored from __doc__\\n pass\",\n \"def __init__(__self__, *,\\n client_certificate_config: Optional[pulumi.Input['ClientCertificateConfigArgs']] = None,\\n cluster_ca_certificate: Optional[pulumi.Input[str]] = None,\\n password: Optional[pulumi.Input[str]] = None,\\n username: Optional[pulumi.Input[str]] = None):\\n if client_certificate_config is not None:\\n pulumi.set(__self__, \\\"client_certificate_config\\\", client_certificate_config)\\n if cluster_ca_certificate is not None:\\n pulumi.set(__self__, \\\"cluster_ca_certificate\\\", cluster_ca_certificate)\\n if password is not None:\\n pulumi.set(__self__, \\\"password\\\", password)\\n if username is not None:\\n pulumi.set(__self__, \\\"username\\\", username)\",\n \"def set_console_font(font):\\n log.debug(\\\"setting console font to %s\\\", font)\\n rc = execWithRedirect(\\\"setfont\\\", [font])\\n if rc == 0:\\n log.debug(\\\"console font set successfully to %s\\\", font)\\n return True\\n else:\\n log.error(\\\"setting console font to %s failed\\\", font)\\n return False\",\n \"def trusted_ca(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"trusted_ca\\\")\",\n \"def trusted_ca(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"trusted_ca\\\")\",\n \"def load_cert_chain(self, certfile, keyfile: Optional[Any] = ...):\\n ...\",\n \"def center(self, center):\\n\\n self._center = center\",\n \"def campaign(self, campaign):\\n\\n self._campaign = campaign\",\n \"def tls_certificate(ca):\\n interface, _host, _port = _get_conn_data(ANY_INTERFACE_IPV4)\\n return ca.issue_cert(ntou(interface))\",\n \"def __init__(__self__, *,\\n ca_bundle: Optional[pulumi.Input[str]] = None,\\n url: Optional[pulumi.Input[str]] = None):\\n if ca_bundle is not None:\\n pulumi.set(__self__, \\\"ca_bundle\\\", ca_bundle)\\n if url is not None:\\n pulumi.set(__self__, \\\"url\\\", url)\",\n \"def __init__(__self__, *,\\n certificate_id: pulumi.Input[str]):\\n pulumi.set(__self__, \\\"certificate_id\\\", certificate_id)\",\n \"def ca():\\n return trustme.CA()\",\n \"def set_vCa(self, in_ca: float) -> None:\\n r: float = self.ion_params.r\\n t: float = self.ion_params.t\\n f: float = self.ion_params.f\\n ex_ca: float = self.concentration['ex_na']\\n vCa: float = r * t / (f * 2) * np.log(ex_ca / in_ca) * 1000\\n self.cav.set_e(new_e=vCa)\",\n \"def sequencing_center(self, sequencing_center):\\n self.logger.debug(\\\"In 'sequencing_center' setter.\\\")\\n\\n self._sequencing_center = sequencing_center\",\n \"def set(self, shell=None):\\n\\n # iterate over the env variable objects and set them in the env\\n for var in self._vars.itervalues():\\n var.set(shell=shell)\",\n \"def cname(self, cname):\\n if (\\n self.local_vars_configuration.client_side_validation and cname is None\\n ): # noqa: E501\\n raise ValueError(\\n \\\"Invalid value for `cname`, must not be `None`\\\"\\n ) # noqa: E501\\n\\n self._cname = cname\",\n \"def ca_file(tmpdir):\\n key = rsa.generate_private_key(public_exponent=65537, key_size=2048)\\n public_key = key.public_key()\\n\\n builder = x509.CertificateBuilder()\\n builder = builder.subject_name(\\n x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, \\\"pyopenssl.org\\\")])\\n )\\n builder = builder.issuer_name(\\n x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, \\\"pyopenssl.org\\\")])\\n )\\n one_day = datetime.timedelta(1, 0, 0)\\n builder = builder.not_valid_before(datetime.datetime.today() - one_day)\\n builder = builder.not_valid_after(datetime.datetime.today() + one_day)\\n builder = builder.serial_number(int(uuid.uuid4()))\\n builder = builder.public_key(public_key)\\n builder = builder.add_extension(\\n x509.BasicConstraints(ca=True, path_length=None),\\n critical=True,\\n )\\n\\n certificate = builder.sign(private_key=key, algorithm=hashes.SHA256())\\n\\n ca_file = tmpdir.join(\\\"test.pem\\\")\\n ca_file.write_binary(\\n certificate.public_bytes(\\n encoding=serialization.Encoding.PEM,\\n )\\n )\\n\\n return str(ca_file).encode(\\\"ascii\\\")\",\n \"def principal(self, principal):\\n\\n self._principal = principal\",\n \"def configure_tomcat_to_load_jacoco_agent(self):\\n open(\\\"/tmp/jacoco.conf\\\", \\\"w\\\").write('JAVA_OPTS=\\\"$JAVA_OPTS -javaagent:/tmp/jacoco-agent.jar=destfile=/tmp/jacoco-it.exec\\\"\\\\n')\\n zone = self.config['zones'][0]['name']\\n for host in self.config['mgtSvr']:\\n connection = {'hostname': host['mgtSvrIp'], 'username': host['user'], 'password': host['passwd']}\\n self.zone = zone\\n src_file = self.workspace + \\\"/target/jacoco-agent.jar\\\"\\n self._scp_put(srcfile=src_file, destfile=\\\"/tmp\\\", **connection)\\n self._scp_put(srcfile=\\\"/tmp/jacoco.conf\\\", destfile=\\\"/etc/tomcat/conf.d/jacoco.conf\\\", **connection)\\n print(\\\"==> Tomcat configured\\\")\\n os.unlink(\\\"/tmp/jacoco.conf\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68265325","0.65130776","0.6440239","0.58595866","0.5228995","0.5037131","0.5037131","0.5013002","0.490777","0.48871157","0.48593655","0.48507708","0.48467252","0.4803529","0.48032707","0.47784925","0.4713782","0.46828216","0.46399626","0.4594442","0.456615","0.455402","0.45468968","0.453434","0.45045602","0.45037642","0.4468689","0.44489378","0.4433251","0.44297794","0.4419738","0.4392339","0.4369054","0.4356983","0.43187106","0.4309392","0.42854935","0.4210915","0.41987872","0.41558182","0.41231135","0.40905076","0.40905076","0.40724146","0.40701818","0.40690967","0.40679574","0.40607378","0.40578842","0.40470806","0.40277308","0.4025629","0.40176183","0.40120628","0.40120628","0.40120628","0.4000494","0.39993334","0.39993334","0.39993334","0.39967397","0.39966735","0.39843842","0.39797956","0.39763534","0.39712653","0.39630395","0.3961042","0.39592895","0.3946758","0.39288","0.39191404","0.39126483","0.38851374","0.38840944","0.3874572","0.38710842","0.38643378","0.3862726","0.3855421","0.38550568","0.38391086","0.38360786","0.38347697","0.38297513","0.38297513","0.38254568","0.38186672","0.38185826","0.38127735","0.3811961","0.380432","0.37939972","0.37893116","0.37873307","0.37836045","0.37620518","0.3756519","0.37545884","0.3751567"],"string":"[\n \"0.68265325\",\n \"0.65130776\",\n \"0.6440239\",\n \"0.58595866\",\n \"0.5228995\",\n \"0.5037131\",\n \"0.5037131\",\n \"0.5013002\",\n \"0.490777\",\n \"0.48871157\",\n \"0.48593655\",\n \"0.48507708\",\n \"0.48467252\",\n \"0.4803529\",\n \"0.48032707\",\n \"0.47784925\",\n \"0.4713782\",\n \"0.46828216\",\n \"0.46399626\",\n \"0.4594442\",\n \"0.456615\",\n \"0.455402\",\n \"0.45468968\",\n \"0.453434\",\n \"0.45045602\",\n \"0.45037642\",\n \"0.4468689\",\n \"0.44489378\",\n \"0.4433251\",\n \"0.44297794\",\n \"0.4419738\",\n \"0.4392339\",\n \"0.4369054\",\n \"0.4356983\",\n \"0.43187106\",\n \"0.4309392\",\n \"0.42854935\",\n \"0.4210915\",\n \"0.41987872\",\n \"0.41558182\",\n \"0.41231135\",\n \"0.40905076\",\n \"0.40905076\",\n \"0.40724146\",\n \"0.40701818\",\n \"0.40690967\",\n \"0.40679574\",\n \"0.40607378\",\n \"0.40578842\",\n \"0.40470806\",\n \"0.40277308\",\n \"0.4025629\",\n \"0.40176183\",\n \"0.40120628\",\n \"0.40120628\",\n \"0.40120628\",\n \"0.4000494\",\n \"0.39993334\",\n \"0.39993334\",\n \"0.39993334\",\n \"0.39967397\",\n \"0.39966735\",\n \"0.39843842\",\n \"0.39797956\",\n \"0.39763534\",\n \"0.39712653\",\n \"0.39630395\",\n \"0.3961042\",\n \"0.39592895\",\n \"0.3946758\",\n \"0.39288\",\n \"0.39191404\",\n \"0.39126483\",\n \"0.38851374\",\n \"0.38840944\",\n \"0.3874572\",\n \"0.38710842\",\n \"0.38643378\",\n \"0.3862726\",\n \"0.3855421\",\n \"0.38550568\",\n \"0.38391086\",\n \"0.38360786\",\n \"0.38347697\",\n \"0.38297513\",\n \"0.38297513\",\n \"0.38254568\",\n \"0.38186672\",\n \"0.38185826\",\n \"0.38127735\",\n \"0.3811961\",\n \"0.380432\",\n \"0.37939972\",\n \"0.37893116\",\n \"0.37873307\",\n \"0.37836045\",\n \"0.37620518\",\n \"0.3756519\",\n \"0.37545884\",\n \"0.3751567\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.85301137"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":24574,"cells":{"query":{"kind":"string","value":"Sets the console_custom_cert of this TypesConsoleCertificateSettings."},"document":{"kind":"string","value":"def console_custom_cert(self, console_custom_cert):\n\n self._console_custom_cert = console_custom_cert"},"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 console_ca_cert(self, console_ca_cert):\n\n self._console_ca_cert = console_ca_cert","def set_custom_property(self, sNewVmCustomProperty):\n\t\tcall_sdk_function('PrlVmCfg_SetCustomProperty', self.handle, sNewVmCustomProperty)","def custom_compliance_domain(self, custom_compliance_domain):\n\n self._custom_compliance_domain = custom_compliance_domain","def custom_domain(self, custom_domain):\n self._custom_domain = custom_domain","def custom_compliance_domain_id(self, custom_compliance_domain_id):\n\n self._custom_compliance_domain_id = custom_compliance_domain_id","def custom_compliance_standard(self, custom_compliance_standard):\n\n self._custom_compliance_standard = custom_compliance_standard","def custom_string(self, custom_string):\n\n self._custom_string = custom_string","def custom(self, custom):\n self._context[\"custom\"] = custom","def custom_attributes(self, custom_attributes):\n\n self._custom_attributes = custom_attributes","def token_cert(self, token_cert):\n\n self._token_cert = token_cert","def custom_data(self, custom_data):\n\n self._custom_data = custom_data","def set_custom_variable(self, key, value):\n self.logger.info(\"Set custom variable : %s:%s\" % (key, value))\n\n try:\n if 'custom_variables' not in self._answer_payload:\n self._answer_payload['custom_variables'] = {}\n self._answer_payload['custom_variables'][key] = value\n except Exception as e:\n self.logger.error(\"Error on set custom variables : %s\" % e)","def custom_compliance_standard_id(self, custom_compliance_standard_id):\n\n self._custom_compliance_standard_id = custom_compliance_standard_id","def set_custom_value(self, value):\n self.logger.info(\"Set custom value : %s\" % value)\n\n try:\n self._answer_payload['custom_value'] = value\n except Exception as e:\n self.logger.error(\"Error on set custom variables : %s\" % e)","def custom_tags(self, custom_tags):\n\n self._custom_tags = custom_tags","def run_custom_config_command(self, context, custom_command):\n with LoggingSessionContext(context) as logger, LogCommand(\n logger, \"run custom config command\"\n ):\n api = CloudShellSessionContext(context).get_api()\n\n resource_config = FirewallResourceConfig.from_context(\n self.SHELL_NAME, context, api, self.SUPPORTED_OS\n )\n\n cli_configurator = CheckpointCliConfigurator(\n self._cli, resource_config, logger\n )\n\n run_command_flow = RunCommandFlow(logger, cli_configurator)\n return run_command_flow.run_custom_config_command(custom_command)","def cert(self, value):\n self._cert = value","def setCustomVar(self, index, name, value, opt_scope=None):\n self.data_struct['_setCustomVar'][index] = (escape_text(name), escape_text(value), opt_scope)","def _use_custom_config(self, standard_conf_path):\n conf_filename = os.path.basename(standard_conf_path)\n custom_conf_expected_path = CUSTOM_CONFIG_DIR + '/' + self._get_tempdir() + '/' + conf_filename\n shutil.copy(custom_conf_expected_path,\n self._get_tempdir() + '/' + standard_conf_path)","def enable_custom_ca_trust(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"enable_custom_ca_trust\")","def set_custom(self, custom):\n custom = clamp(custom, 1, 12)\n self._state.mode = custom\n self.send_command(Command.SET_CUSTOM, [int(custom)])","def custom_signatures(self, custom_signatures):\n\n self._custom_signatures = custom_signatures","def setCustomData( self, key, value ):\n self._customData[str(key)] = value","def client_cert(self, client_cert):\n\n self._client_cert = client_cert","def addCustomDocumentProperty(self,name,value):\n self.PDFreactorConfiguration.in1[\"customDocumentProperties\"].append([name, value])","def ca_cert(self, ca_cert):\n\n self._ca_cert = ca_cert","def is_custom(self, is_custom):\n\n self._is_custom = is_custom","def is_custom(self, is_custom):\n\n self._is_custom = is_custom","def custom_user_id(self, custom_user_id):\n # type: (string_types) -> None\n\n if custom_user_id is not None:\n if not isinstance(custom_user_id, string_types):\n raise TypeError(\"Invalid type for `custom_user_id`, type has to be `string_types`\")\n\n self._custom_user_id = custom_user_id","def limit(self, custom_limit):\n # NOTE(gibi): this operation needs escalated privileges (e.g. admin)\n # as the owner of the app cannot set its own app's limits. But\n # authorization is out of scope.\n self._limit = custom_limit","def user_custom_data(self, user_custom_data):\n\n self._user_custom_data = user_custom_data","def custom(self) -> Optional[pulumi.Input['ConnectorProfileConnectorProfileConfigConnectorProfileCredentialsCustomConnectorCustomArgs']]:\n return pulumi.get(self, \"custom\")","def custom_data_field_labels(self, custom_data_field_labels):\n # type: (AnalyticsLicenseCustomDataFieldLabels) -> None\n\n if custom_data_field_labels is not None:\n if not isinstance(custom_data_field_labels, AnalyticsLicenseCustomDataFieldLabels):\n raise TypeError(\"Invalid type for `custom_data_field_labels`, type has to be `AnalyticsLicenseCustomDataFieldLabels`\")\n\n self._custom_data_field_labels = custom_data_field_labels","def custom_data_10(self, custom_data_10):\n # type: (string_types) -> None\n\n if custom_data_10 is not None:\n if not isinstance(custom_data_10, string_types):\n raise TypeError(\"Invalid type for `custom_data_10`, type has to be `string_types`\")\n\n self._custom_data_10 = custom_data_10","def developer_certificate_identity(self, developer_certificate_identity):\n\n self._developer_certificate_identity = developer_certificate_identity","def mdm_signing_certificate(self, mdm_signing_certificate):\n\n self._mdm_signing_certificate = mdm_signing_certificate","def setOverrideCertificateErrors(self, override: bool) -> Awaitable[Dict]:\n return self.client.send(\n \"Security.setOverrideCertificateErrors\", {\"override\": override}\n )","def syslog_config_from_platform_setting(self, syslog_config_from_platform_setting):\n\n self._syslog_config_from_platform_setting = syslog_config_from_platform_setting","def custom_launch_address_allowed(self, custom_launch_address_allowed):\n\n self._custom_launch_address_allowed = custom_launch_address_allowed","def syslog_config(self, syslog_config):\n\n self._syslog_config = syslog_config","def add_page_custom_var(self, key, value):\n self._add_custom_var(key, value, 'cvar')","def custom_data_12(self, custom_data_12):\n # type: (string_types) -> None\n\n if custom_data_12 is not None:\n if not isinstance(custom_data_12, string_types):\n raise TypeError(\"Invalid type for `custom_data_12`, type has to be `string_types`\")\n\n self._custom_data_12 = custom_data_12","def store_own_cert(self, certstring=None, certpath=None):\n# _log.debug(\"store_own_cert:\\n\\tcertstring={}\\n\\tcertpath={}\".format(certstring, certpath))\n path = self._store_cert(\"mine\", certstring=certstring, certpath=certpath)\n #Let's update openssl.conf, but this entry should probably not\n #be trusted, it is likely that someone will copy certs into the folder \n #by other means\n# self.configuration['RT_default']['certificate'] = path\n# self.update_opensslconf()\n self.cert_name = self.get_own_cert_name()\n self.cert_path = self.get_own_cert_path()\n return path","def custom_data_16(self, custom_data_16):\n # type: (string_types) -> None\n\n if custom_data_16 is not None:\n if not isinstance(custom_data_16, string_types):\n raise TypeError(\"Invalid type for `custom_data_16`, type has to be `string_types`\")\n\n self._custom_data_16 = custom_data_16","def _do_custom(self, custom):\n if custom:\n self.words[-1].custom_tags.update(custom)","def setCustomBounds(self, value):\n return self._set(customBounds=value)","def custom_fields(self, custom_fields):\n\n self._custom_fields = custom_fields","def custom_fields(self, custom_fields):\n\n self._custom_fields = custom_fields","def custom_fields(self, custom_fields):\n\n self._custom_fields = custom_fields","def custom_fields(self, custom_fields):\n\n self._custom_fields = custom_fields","def custom_fields(self, custom_fields):\n\n self._custom_fields = custom_fields","def save_ca():\n cert_file = os.environ.get('HOME') + '/.cat_installer/ca.pem'\n debug(\"saving cert\")\n with open(cert_file, 'w') as cert:\n cert.write(Config.CA + \"\\n\")","def setCertfile(self, certfile):\r\n if not os.access(certfile, os.R_OK):\r\n raise IOError('No such certfile found: %s' % (certfile))\r\n self.certfile = certfile","def custom_data_14(self, custom_data_14):\n # type: (string_types) -> None\n\n if custom_data_14 is not None:\n if not isinstance(custom_data_14, string_types):\n raise TypeError(\"Invalid type for `custom_data_14`, type has to be `string_types`\")\n\n self._custom_data_14 = custom_data_14","def certificate(self, certificate):\n\n self._certificate = certificate","def custom_info2(self, custom_info2):\n\n self._custom_info2 = custom_info2","def custom_info2(self, custom_info2):\n\n self._custom_info2 = custom_info2","def set_text_attr(color):\n SetConsoleTextAttribute(stdout_handle, color)","def __init__(__self__, *,\n customer_managed_key_encryption: Optional[pulumi.Input['ClusterPropertiesCustomerManagedKeyEncryptionArgs']] = None):\n if customer_managed_key_encryption is not None:\n pulumi.set(__self__, \"customer_managed_key_encryption\", customer_managed_key_encryption)","def customer_uuid(self, customer_uuid):\n\n self._customer_uuid = customer_uuid","def set_ssl_socket(self, socket):\n Server.t_ssl_sockets[threading.get_ident()] = socket","def custom_profile_fields(self, custom_profile_fields):\n\n self._custom_profile_fields = custom_profile_fields","def svn_client_ctx_t_config_set(svn_client_ctx_t_self, apr_hash_t_config): # real signature unknown; restored from __doc__\n pass","def org_apache_felix_https_clientcertificate(self, org_apache_felix_https_clientcertificate: ConfigNodePropertyDropDown):\n\n self._org_apache_felix_https_clientcertificate = org_apache_felix_https_clientcertificate","def run_custom_command(self, context, custom_command):\n with LoggingSessionContext(context) as logger, LogCommand(\n logger, \"run custom command\"\n ):\n api = CloudShellSessionContext(context).get_api()\n\n resource_config = FirewallResourceConfig.from_context(\n self.SHELL_NAME, context, api, self.SUPPORTED_OS\n )\n\n cli_configurator = CheckpointCliConfigurator(\n self._cli, resource_config, logger\n )\n\n run_command_flow = RunCommandFlow(logger, cli_configurator)\n return run_command_flow.run_custom_command(custom_command)","def custom_data_13(self, custom_data_13):\n # type: (string_types) -> None\n\n if custom_data_13 is not None:\n if not isinstance(custom_data_13, string_types):\n raise TypeError(\"Invalid type for `custom_data_13`, type has to be `string_types`\")\n\n self._custom_data_13 = custom_data_13","def custom_connector(self) -> Optional[pulumi.Input['ConnectorProfileConnectorProfileConfigConnectorProfileCredentialsCustomConnectorArgs']]:\n return pulumi.get(self, \"custom_connector\")","def mcs(self, mcs):\n\n self._block.tx_policies[self._lvap.addr].mcs = mcs","def custom_data_25(self, custom_data_25):\n # type: (string_types) -> None\n\n if custom_data_25 is not None:\n if not isinstance(custom_data_25, string_types):\n raise TypeError(\"Invalid type for `custom_data_25`, type has to be `string_types`\")\n\n self._custom_data_25 = custom_data_25","def __eq__(self, other):\n if not isinstance(other, TypesConsoleCertificateSettings):\n return False\n\n return self.to_dict() == other.to_dict()","def set_CustomWebsiteRedirection(self, value):\n super(PutBucketWebsiteRedirectInputSet, self)._set_input('CustomWebsiteRedirection', value)","def custom_data_18(self, custom_data_18):\n # type: (string_types) -> None\n\n if custom_data_18 is not None:\n if not isinstance(custom_data_18, string_types):\n raise TypeError(\"Invalid type for `custom_data_18`, type has to be `string_types`\")\n\n self._custom_data_18 = custom_data_18","def trusted_server_certificates(self, trusted_server_certificates):\n if trusted_server_certificates is not None and len(trusted_server_certificates) > 100000:\n raise ValueError(\"Invalid value for `trusted_server_certificates`, length must be less than or equal to `100000`\")\n if trusted_server_certificates is not None and len(trusted_server_certificates) < 0:\n raise ValueError(\"Invalid value for `trusted_server_certificates`, length must be greater than or equal to `0`\")\n\n self._trusted_server_certificates = trusted_server_certificates","def set_custom_attribute(self, name: str, value: int):\n\n if name not in self.CUSTOM_ATTRIBUTES:\n raise ValueError(f\"Failed to set custom attribute {name} with value {value} for Labourer {self.id}. \"\n f\"Supported attributes are: {', '.join(self.CUSTOM_ATTRIBUTES)}.\")\n logger.debug(f\"Labourer {self.id} set custom attribute {name} with {value}\")\n setattr(self, name, value)","def custom_data_2(self, custom_data_2):\n # type: (string_types) -> None\n\n if custom_data_2 is not None:\n if not isinstance(custom_data_2, string_types):\n raise TypeError(\"Invalid type for `custom_data_2`, type has to be `string_types`\")\n\n self._custom_data_2 = custom_data_2","def custom_data_27(self, custom_data_27):\n # type: (string_types) -> None\n\n if custom_data_27 is not None:\n if not isinstance(custom_data_27, string_types):\n raise TypeError(\"Invalid type for `custom_data_27`, type has to be `string_types`\")\n\n self._custom_data_27 = custom_data_27","def assign(id, type, appid, specialid):\n try:\n client().certificates.assign(id, type, appid, specialid)\n logger.info(\n 'ctl:cert:assign', 'Assigned {0} to {0}'.format(id, appid)\n )\n except Exception as e:\n raise CLIException(str(e))","def definearguments(self, customparser):\n\n customparser.add_option(\n '--disable',\n action=\"store_false\",\n dest=\"enableFeature\",\n help=\"Disable the Scalable Persistent Memory feature. Warning: \"\\\n \"any pending configuration changes will be lost.\"\n )","def __init__(self, terminal):\r\n super(CustomOptions, self).__init__()\r\n self.longdesc = \"\"\r\n self.terminal = terminal","def custom_connector(self) -> Optional[pulumi.Input['ConnectorProfileConnectorProfileConfigConnectorProfilePropertiesCustomConnectorArgs']]:\n return pulumi.get(self, \"custom_connector\")","def disk_config(self, disk_config):\n\n self._disk_config = disk_config","def set_canvas_coords(self, visual_x, visual_y, visual_r):\n self.visual_y = visual_y\n self.visual_x = visual_x\n self.visual_r = visual_r","def custom_enroll_flag(self, custom_enroll_flag):\n\n self._custom_enroll_flag = custom_enroll_flag","def add_visit_custom_var(self, key, value):\n self._add_custom_var(key, value, '_cvar')","def custom_data_8(self, custom_data_8):\n # type: (string_types) -> None\n\n if custom_data_8 is not None:\n if not isinstance(custom_data_8, string_types):\n raise TypeError(\"Invalid type for `custom_data_8`, type has to be `string_types`\")\n\n self._custom_data_8 = custom_data_8","def set(font='Serif', fontsize=11, figsize=(8.6, 8.6),\n linewidth=1.5, color_scheme=color_scheme,\n color_labels=color_labels):\n params = {\n 'font.size': fontsize,\n 'backend': 'PDF',\n 'font.family': font,\n 'figure.figsize': (figsize[0]/2.54, figsize[1]/2.54),\n 'axes.prop_cycle': plt.cycler('color', color_scheme),\n 'axes.formatter.useoffset': False,\n 'lines.linewidth': linewidth,\n 'axes.axisbelow': True, # Grid axis below data\n 'grid.color': '#BFBFBF',\n 'grid.linestyle': '-',\n 'legend.fontsize': 10,\n 'figure.dpi': 200\n }\n\n plt.rcParams.update(params)\n builtins.cc = dict(zip(color_labels, color_scheme))","def auth_provider_x509_cert_url(self, auth_provider_x509_cert_url):\n\n self._auth_provider_x509_cert_url = auth_provider_x509_cert_url","def custom_feed(self, custom_feed):\n\n self._custom_feed = custom_feed","def configure_custom_terminal(new_path):\n lnp.userconfig['terminal'] = new_path\n lnp.userconfig.save_data()","def set_up_oidc_issuer_profile(self, mc: ManagedCluster) -> ManagedCluster:\n self._ensure_mc(mc)\n oidc_issuer_profile = self.context.get_oidc_issuer_profile()\n if oidc_issuer_profile is not None:\n mc.oidc_issuer_profile = oidc_issuer_profile\n\n return mc","def _setbeneficiary_customer_no_option_59(self, val):\n self.swift_obj.BeneficiaryCustomer = val\n self.swift_obj.BeneficiaryCustomer.swiftTag = '59'","def set_config(self, attr, value):\n setattr(self.config, attr, value)","def set_config(self, attr, value):\n setattr(self.config, attr, value)","def custom_data_26(self, custom_data_26):\n # type: (string_types) -> None\n\n if custom_data_26 is not None:\n if not isinstance(custom_data_26, string_types):\n raise TypeError(\"Invalid type for `custom_data_26`, type has to be `string_types`\")\n\n self._custom_data_26 = custom_data_26","def person_mac(self, person_mac):\n\n self._person_mac = person_mac","def add_console_setting(db, linenum, baud, flowcontrol, devicename):\n config_db = db.cfgdb\n\n table = \"CONSOLE_PORT\"\n dataKey1 = 'baud_rate'\n dataKey2 = 'flow_control'\n dataKey3 = 'remote_device'\n\n ctx = click.get_current_context()\n data = config_db.get_entry(table, linenum)\n if data:\n ctx.fail(\"Trying to add console port setting, which is already exists.\")\n else:\n console_entry = { dataKey1: baud }\n console_entry[dataKey2] = \"1\" if flowcontrol else \"0\"\n\n if devicename:\n if isExistingSameDevice(config_db, devicename, table):\n ctx.fail(\"Given device name {} has been used. Please enter a valid device name or remove the existing one !!\".format(devicename))\n console_entry[dataKey3] = devicename\n\n config_db.set_entry(table, linenum, console_entry)","def customer_profile_oid(self, customer_profile_oid):\n\n self._customer_profile_oid = customer_profile_oid","def set_trial_system_attr(self, trial_id: int, key: str, value: Any) -> None:\n raise NotImplementedError","def custom_data_15(self, custom_data_15):\n # type: (string_types) -> None\n\n if custom_data_15 is not None:\n if not isinstance(custom_data_15, string_types):\n raise TypeError(\"Invalid type for `custom_data_15`, type has to be `string_types`\")\n\n self._custom_data_15 = custom_data_15","def register(self, cert: x509.Certificate):\n raise NotImplementedError"],"string":"[\n \"def console_ca_cert(self, console_ca_cert):\\n\\n self._console_ca_cert = console_ca_cert\",\n \"def set_custom_property(self, sNewVmCustomProperty):\\n\\t\\tcall_sdk_function('PrlVmCfg_SetCustomProperty', self.handle, sNewVmCustomProperty)\",\n \"def custom_compliance_domain(self, custom_compliance_domain):\\n\\n self._custom_compliance_domain = custom_compliance_domain\",\n \"def custom_domain(self, custom_domain):\\n self._custom_domain = custom_domain\",\n \"def custom_compliance_domain_id(self, custom_compliance_domain_id):\\n\\n self._custom_compliance_domain_id = custom_compliance_domain_id\",\n \"def custom_compliance_standard(self, custom_compliance_standard):\\n\\n self._custom_compliance_standard = custom_compliance_standard\",\n \"def custom_string(self, custom_string):\\n\\n self._custom_string = custom_string\",\n \"def custom(self, custom):\\n self._context[\\\"custom\\\"] = custom\",\n \"def custom_attributes(self, custom_attributes):\\n\\n self._custom_attributes = custom_attributes\",\n \"def token_cert(self, token_cert):\\n\\n self._token_cert = token_cert\",\n \"def custom_data(self, custom_data):\\n\\n self._custom_data = custom_data\",\n \"def set_custom_variable(self, key, value):\\n self.logger.info(\\\"Set custom variable : %s:%s\\\" % (key, value))\\n\\n try:\\n if 'custom_variables' not in self._answer_payload:\\n self._answer_payload['custom_variables'] = {}\\n self._answer_payload['custom_variables'][key] = value\\n except Exception as e:\\n self.logger.error(\\\"Error on set custom variables : %s\\\" % e)\",\n \"def custom_compliance_standard_id(self, custom_compliance_standard_id):\\n\\n self._custom_compliance_standard_id = custom_compliance_standard_id\",\n \"def set_custom_value(self, value):\\n self.logger.info(\\\"Set custom value : %s\\\" % value)\\n\\n try:\\n self._answer_payload['custom_value'] = value\\n except Exception as e:\\n self.logger.error(\\\"Error on set custom variables : %s\\\" % e)\",\n \"def custom_tags(self, custom_tags):\\n\\n self._custom_tags = custom_tags\",\n \"def run_custom_config_command(self, context, custom_command):\\n with LoggingSessionContext(context) as logger, LogCommand(\\n logger, \\\"run custom config command\\\"\\n ):\\n api = CloudShellSessionContext(context).get_api()\\n\\n resource_config = FirewallResourceConfig.from_context(\\n self.SHELL_NAME, context, api, self.SUPPORTED_OS\\n )\\n\\n cli_configurator = CheckpointCliConfigurator(\\n self._cli, resource_config, logger\\n )\\n\\n run_command_flow = RunCommandFlow(logger, cli_configurator)\\n return run_command_flow.run_custom_config_command(custom_command)\",\n \"def cert(self, value):\\n self._cert = value\",\n \"def setCustomVar(self, index, name, value, opt_scope=None):\\n self.data_struct['_setCustomVar'][index] = (escape_text(name), escape_text(value), opt_scope)\",\n \"def _use_custom_config(self, standard_conf_path):\\n conf_filename = os.path.basename(standard_conf_path)\\n custom_conf_expected_path = CUSTOM_CONFIG_DIR + '/' + self._get_tempdir() + '/' + conf_filename\\n shutil.copy(custom_conf_expected_path,\\n self._get_tempdir() + '/' + standard_conf_path)\",\n \"def enable_custom_ca_trust(self) -> Optional[pulumi.Input[bool]]:\\n return pulumi.get(self, \\\"enable_custom_ca_trust\\\")\",\n \"def set_custom(self, custom):\\n custom = clamp(custom, 1, 12)\\n self._state.mode = custom\\n self.send_command(Command.SET_CUSTOM, [int(custom)])\",\n \"def custom_signatures(self, custom_signatures):\\n\\n self._custom_signatures = custom_signatures\",\n \"def setCustomData( self, key, value ):\\n self._customData[str(key)] = value\",\n \"def client_cert(self, client_cert):\\n\\n self._client_cert = client_cert\",\n \"def addCustomDocumentProperty(self,name,value):\\n self.PDFreactorConfiguration.in1[\\\"customDocumentProperties\\\"].append([name, value])\",\n \"def ca_cert(self, ca_cert):\\n\\n self._ca_cert = ca_cert\",\n \"def is_custom(self, is_custom):\\n\\n self._is_custom = is_custom\",\n \"def is_custom(self, is_custom):\\n\\n self._is_custom = is_custom\",\n \"def custom_user_id(self, custom_user_id):\\n # type: (string_types) -> None\\n\\n if custom_user_id is not None:\\n if not isinstance(custom_user_id, string_types):\\n raise TypeError(\\\"Invalid type for `custom_user_id`, type has to be `string_types`\\\")\\n\\n self._custom_user_id = custom_user_id\",\n \"def limit(self, custom_limit):\\n # NOTE(gibi): this operation needs escalated privileges (e.g. admin)\\n # as the owner of the app cannot set its own app's limits. But\\n # authorization is out of scope.\\n self._limit = custom_limit\",\n \"def user_custom_data(self, user_custom_data):\\n\\n self._user_custom_data = user_custom_data\",\n \"def custom(self) -> Optional[pulumi.Input['ConnectorProfileConnectorProfileConfigConnectorProfileCredentialsCustomConnectorCustomArgs']]:\\n return pulumi.get(self, \\\"custom\\\")\",\n \"def custom_data_field_labels(self, custom_data_field_labels):\\n # type: (AnalyticsLicenseCustomDataFieldLabels) -> None\\n\\n if custom_data_field_labels is not None:\\n if not isinstance(custom_data_field_labels, AnalyticsLicenseCustomDataFieldLabels):\\n raise TypeError(\\\"Invalid type for `custom_data_field_labels`, type has to be `AnalyticsLicenseCustomDataFieldLabels`\\\")\\n\\n self._custom_data_field_labels = custom_data_field_labels\",\n \"def custom_data_10(self, custom_data_10):\\n # type: (string_types) -> None\\n\\n if custom_data_10 is not None:\\n if not isinstance(custom_data_10, string_types):\\n raise TypeError(\\\"Invalid type for `custom_data_10`, type has to be `string_types`\\\")\\n\\n self._custom_data_10 = custom_data_10\",\n \"def developer_certificate_identity(self, developer_certificate_identity):\\n\\n self._developer_certificate_identity = developer_certificate_identity\",\n \"def mdm_signing_certificate(self, mdm_signing_certificate):\\n\\n self._mdm_signing_certificate = mdm_signing_certificate\",\n \"def setOverrideCertificateErrors(self, override: bool) -> Awaitable[Dict]:\\n return self.client.send(\\n \\\"Security.setOverrideCertificateErrors\\\", {\\\"override\\\": override}\\n )\",\n \"def syslog_config_from_platform_setting(self, syslog_config_from_platform_setting):\\n\\n self._syslog_config_from_platform_setting = syslog_config_from_platform_setting\",\n \"def custom_launch_address_allowed(self, custom_launch_address_allowed):\\n\\n self._custom_launch_address_allowed = custom_launch_address_allowed\",\n \"def syslog_config(self, syslog_config):\\n\\n self._syslog_config = syslog_config\",\n \"def add_page_custom_var(self, key, value):\\n self._add_custom_var(key, value, 'cvar')\",\n \"def custom_data_12(self, custom_data_12):\\n # type: (string_types) -> None\\n\\n if custom_data_12 is not None:\\n if not isinstance(custom_data_12, string_types):\\n raise TypeError(\\\"Invalid type for `custom_data_12`, type has to be `string_types`\\\")\\n\\n self._custom_data_12 = custom_data_12\",\n \"def store_own_cert(self, certstring=None, certpath=None):\\n# _log.debug(\\\"store_own_cert:\\\\n\\\\tcertstring={}\\\\n\\\\tcertpath={}\\\".format(certstring, certpath))\\n path = self._store_cert(\\\"mine\\\", certstring=certstring, certpath=certpath)\\n #Let's update openssl.conf, but this entry should probably not\\n #be trusted, it is likely that someone will copy certs into the folder \\n #by other means\\n# self.configuration['RT_default']['certificate'] = path\\n# self.update_opensslconf()\\n self.cert_name = self.get_own_cert_name()\\n self.cert_path = self.get_own_cert_path()\\n return path\",\n \"def custom_data_16(self, custom_data_16):\\n # type: (string_types) -> None\\n\\n if custom_data_16 is not None:\\n if not isinstance(custom_data_16, string_types):\\n raise TypeError(\\\"Invalid type for `custom_data_16`, type has to be `string_types`\\\")\\n\\n self._custom_data_16 = custom_data_16\",\n \"def _do_custom(self, custom):\\n if custom:\\n self.words[-1].custom_tags.update(custom)\",\n \"def setCustomBounds(self, value):\\n return self._set(customBounds=value)\",\n \"def custom_fields(self, custom_fields):\\n\\n self._custom_fields = custom_fields\",\n \"def custom_fields(self, custom_fields):\\n\\n self._custom_fields = custom_fields\",\n \"def custom_fields(self, custom_fields):\\n\\n self._custom_fields = custom_fields\",\n \"def custom_fields(self, custom_fields):\\n\\n self._custom_fields = custom_fields\",\n \"def custom_fields(self, custom_fields):\\n\\n self._custom_fields = custom_fields\",\n \"def save_ca():\\n cert_file = os.environ.get('HOME') + '/.cat_installer/ca.pem'\\n debug(\\\"saving cert\\\")\\n with open(cert_file, 'w') as cert:\\n cert.write(Config.CA + \\\"\\\\n\\\")\",\n \"def setCertfile(self, certfile):\\r\\n if not os.access(certfile, os.R_OK):\\r\\n raise IOError('No such certfile found: %s' % (certfile))\\r\\n self.certfile = certfile\",\n \"def custom_data_14(self, custom_data_14):\\n # type: (string_types) -> None\\n\\n if custom_data_14 is not None:\\n if not isinstance(custom_data_14, string_types):\\n raise TypeError(\\\"Invalid type for `custom_data_14`, type has to be `string_types`\\\")\\n\\n self._custom_data_14 = custom_data_14\",\n \"def certificate(self, certificate):\\n\\n self._certificate = certificate\",\n \"def custom_info2(self, custom_info2):\\n\\n self._custom_info2 = custom_info2\",\n \"def custom_info2(self, custom_info2):\\n\\n self._custom_info2 = custom_info2\",\n \"def set_text_attr(color):\\n SetConsoleTextAttribute(stdout_handle, color)\",\n \"def __init__(__self__, *,\\n customer_managed_key_encryption: Optional[pulumi.Input['ClusterPropertiesCustomerManagedKeyEncryptionArgs']] = None):\\n if customer_managed_key_encryption is not None:\\n pulumi.set(__self__, \\\"customer_managed_key_encryption\\\", customer_managed_key_encryption)\",\n \"def customer_uuid(self, customer_uuid):\\n\\n self._customer_uuid = customer_uuid\",\n \"def set_ssl_socket(self, socket):\\n Server.t_ssl_sockets[threading.get_ident()] = socket\",\n \"def custom_profile_fields(self, custom_profile_fields):\\n\\n self._custom_profile_fields = custom_profile_fields\",\n \"def svn_client_ctx_t_config_set(svn_client_ctx_t_self, apr_hash_t_config): # real signature unknown; restored from __doc__\\n pass\",\n \"def org_apache_felix_https_clientcertificate(self, org_apache_felix_https_clientcertificate: ConfigNodePropertyDropDown):\\n\\n self._org_apache_felix_https_clientcertificate = org_apache_felix_https_clientcertificate\",\n \"def run_custom_command(self, context, custom_command):\\n with LoggingSessionContext(context) as logger, LogCommand(\\n logger, \\\"run custom command\\\"\\n ):\\n api = CloudShellSessionContext(context).get_api()\\n\\n resource_config = FirewallResourceConfig.from_context(\\n self.SHELL_NAME, context, api, self.SUPPORTED_OS\\n )\\n\\n cli_configurator = CheckpointCliConfigurator(\\n self._cli, resource_config, logger\\n )\\n\\n run_command_flow = RunCommandFlow(logger, cli_configurator)\\n return run_command_flow.run_custom_command(custom_command)\",\n \"def custom_data_13(self, custom_data_13):\\n # type: (string_types) -> None\\n\\n if custom_data_13 is not None:\\n if not isinstance(custom_data_13, string_types):\\n raise TypeError(\\\"Invalid type for `custom_data_13`, type has to be `string_types`\\\")\\n\\n self._custom_data_13 = custom_data_13\",\n \"def custom_connector(self) -> Optional[pulumi.Input['ConnectorProfileConnectorProfileConfigConnectorProfileCredentialsCustomConnectorArgs']]:\\n return pulumi.get(self, \\\"custom_connector\\\")\",\n \"def mcs(self, mcs):\\n\\n self._block.tx_policies[self._lvap.addr].mcs = mcs\",\n \"def custom_data_25(self, custom_data_25):\\n # type: (string_types) -> None\\n\\n if custom_data_25 is not None:\\n if not isinstance(custom_data_25, string_types):\\n raise TypeError(\\\"Invalid type for `custom_data_25`, type has to be `string_types`\\\")\\n\\n self._custom_data_25 = custom_data_25\",\n \"def __eq__(self, other):\\n if not isinstance(other, TypesConsoleCertificateSettings):\\n return False\\n\\n return self.to_dict() == other.to_dict()\",\n \"def set_CustomWebsiteRedirection(self, value):\\n super(PutBucketWebsiteRedirectInputSet, self)._set_input('CustomWebsiteRedirection', value)\",\n \"def custom_data_18(self, custom_data_18):\\n # type: (string_types) -> None\\n\\n if custom_data_18 is not None:\\n if not isinstance(custom_data_18, string_types):\\n raise TypeError(\\\"Invalid type for `custom_data_18`, type has to be `string_types`\\\")\\n\\n self._custom_data_18 = custom_data_18\",\n \"def trusted_server_certificates(self, trusted_server_certificates):\\n if trusted_server_certificates is not None and len(trusted_server_certificates) > 100000:\\n raise ValueError(\\\"Invalid value for `trusted_server_certificates`, length must be less than or equal to `100000`\\\")\\n if trusted_server_certificates is not None and len(trusted_server_certificates) < 0:\\n raise ValueError(\\\"Invalid value for `trusted_server_certificates`, length must be greater than or equal to `0`\\\")\\n\\n self._trusted_server_certificates = trusted_server_certificates\",\n \"def set_custom_attribute(self, name: str, value: int):\\n\\n if name not in self.CUSTOM_ATTRIBUTES:\\n raise ValueError(f\\\"Failed to set custom attribute {name} with value {value} for Labourer {self.id}. \\\"\\n f\\\"Supported attributes are: {', '.join(self.CUSTOM_ATTRIBUTES)}.\\\")\\n logger.debug(f\\\"Labourer {self.id} set custom attribute {name} with {value}\\\")\\n setattr(self, name, value)\",\n \"def custom_data_2(self, custom_data_2):\\n # type: (string_types) -> None\\n\\n if custom_data_2 is not None:\\n if not isinstance(custom_data_2, string_types):\\n raise TypeError(\\\"Invalid type for `custom_data_2`, type has to be `string_types`\\\")\\n\\n self._custom_data_2 = custom_data_2\",\n \"def custom_data_27(self, custom_data_27):\\n # type: (string_types) -> None\\n\\n if custom_data_27 is not None:\\n if not isinstance(custom_data_27, string_types):\\n raise TypeError(\\\"Invalid type for `custom_data_27`, type has to be `string_types`\\\")\\n\\n self._custom_data_27 = custom_data_27\",\n \"def assign(id, type, appid, specialid):\\n try:\\n client().certificates.assign(id, type, appid, specialid)\\n logger.info(\\n 'ctl:cert:assign', 'Assigned {0} to {0}'.format(id, appid)\\n )\\n except Exception as e:\\n raise CLIException(str(e))\",\n \"def definearguments(self, customparser):\\n\\n customparser.add_option(\\n '--disable',\\n action=\\\"store_false\\\",\\n dest=\\\"enableFeature\\\",\\n help=\\\"Disable the Scalable Persistent Memory feature. Warning: \\\"\\\\\\n \\\"any pending configuration changes will be lost.\\\"\\n )\",\n \"def __init__(self, terminal):\\r\\n super(CustomOptions, self).__init__()\\r\\n self.longdesc = \\\"\\\"\\r\\n self.terminal = terminal\",\n \"def custom_connector(self) -> Optional[pulumi.Input['ConnectorProfileConnectorProfileConfigConnectorProfilePropertiesCustomConnectorArgs']]:\\n return pulumi.get(self, \\\"custom_connector\\\")\",\n \"def disk_config(self, disk_config):\\n\\n self._disk_config = disk_config\",\n \"def set_canvas_coords(self, visual_x, visual_y, visual_r):\\n self.visual_y = visual_y\\n self.visual_x = visual_x\\n self.visual_r = visual_r\",\n \"def custom_enroll_flag(self, custom_enroll_flag):\\n\\n self._custom_enroll_flag = custom_enroll_flag\",\n \"def add_visit_custom_var(self, key, value):\\n self._add_custom_var(key, value, '_cvar')\",\n \"def custom_data_8(self, custom_data_8):\\n # type: (string_types) -> None\\n\\n if custom_data_8 is not None:\\n if not isinstance(custom_data_8, string_types):\\n raise TypeError(\\\"Invalid type for `custom_data_8`, type has to be `string_types`\\\")\\n\\n self._custom_data_8 = custom_data_8\",\n \"def set(font='Serif', fontsize=11, figsize=(8.6, 8.6),\\n linewidth=1.5, color_scheme=color_scheme,\\n color_labels=color_labels):\\n params = {\\n 'font.size': fontsize,\\n 'backend': 'PDF',\\n 'font.family': font,\\n 'figure.figsize': (figsize[0]/2.54, figsize[1]/2.54),\\n 'axes.prop_cycle': plt.cycler('color', color_scheme),\\n 'axes.formatter.useoffset': False,\\n 'lines.linewidth': linewidth,\\n 'axes.axisbelow': True, # Grid axis below data\\n 'grid.color': '#BFBFBF',\\n 'grid.linestyle': '-',\\n 'legend.fontsize': 10,\\n 'figure.dpi': 200\\n }\\n\\n plt.rcParams.update(params)\\n builtins.cc = dict(zip(color_labels, color_scheme))\",\n \"def auth_provider_x509_cert_url(self, auth_provider_x509_cert_url):\\n\\n self._auth_provider_x509_cert_url = auth_provider_x509_cert_url\",\n \"def custom_feed(self, custom_feed):\\n\\n self._custom_feed = custom_feed\",\n \"def configure_custom_terminal(new_path):\\n lnp.userconfig['terminal'] = new_path\\n lnp.userconfig.save_data()\",\n \"def set_up_oidc_issuer_profile(self, mc: ManagedCluster) -> ManagedCluster:\\n self._ensure_mc(mc)\\n oidc_issuer_profile = self.context.get_oidc_issuer_profile()\\n if oidc_issuer_profile is not None:\\n mc.oidc_issuer_profile = oidc_issuer_profile\\n\\n return mc\",\n \"def _setbeneficiary_customer_no_option_59(self, val):\\n self.swift_obj.BeneficiaryCustomer = val\\n self.swift_obj.BeneficiaryCustomer.swiftTag = '59'\",\n \"def set_config(self, attr, value):\\n setattr(self.config, attr, value)\",\n \"def set_config(self, attr, value):\\n setattr(self.config, attr, value)\",\n \"def custom_data_26(self, custom_data_26):\\n # type: (string_types) -> None\\n\\n if custom_data_26 is not None:\\n if not isinstance(custom_data_26, string_types):\\n raise TypeError(\\\"Invalid type for `custom_data_26`, type has to be `string_types`\\\")\\n\\n self._custom_data_26 = custom_data_26\",\n \"def person_mac(self, person_mac):\\n\\n self._person_mac = person_mac\",\n \"def add_console_setting(db, linenum, baud, flowcontrol, devicename):\\n config_db = db.cfgdb\\n\\n table = \\\"CONSOLE_PORT\\\"\\n dataKey1 = 'baud_rate'\\n dataKey2 = 'flow_control'\\n dataKey3 = 'remote_device'\\n\\n ctx = click.get_current_context()\\n data = config_db.get_entry(table, linenum)\\n if data:\\n ctx.fail(\\\"Trying to add console port setting, which is already exists.\\\")\\n else:\\n console_entry = { dataKey1: baud }\\n console_entry[dataKey2] = \\\"1\\\" if flowcontrol else \\\"0\\\"\\n\\n if devicename:\\n if isExistingSameDevice(config_db, devicename, table):\\n ctx.fail(\\\"Given device name {} has been used. Please enter a valid device name or remove the existing one !!\\\".format(devicename))\\n console_entry[dataKey3] = devicename\\n\\n config_db.set_entry(table, linenum, console_entry)\",\n \"def customer_profile_oid(self, customer_profile_oid):\\n\\n self._customer_profile_oid = customer_profile_oid\",\n \"def set_trial_system_attr(self, trial_id: int, key: str, value: Any) -> None:\\n raise NotImplementedError\",\n \"def custom_data_15(self, custom_data_15):\\n # type: (string_types) -> None\\n\\n if custom_data_15 is not None:\\n if not isinstance(custom_data_15, string_types):\\n raise TypeError(\\\"Invalid type for `custom_data_15`, type has to be `string_types`\\\")\\n\\n self._custom_data_15 = custom_data_15\",\n \"def register(self, cert: x509.Certificate):\\n raise NotImplementedError\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6610284","0.54055816","0.53626394","0.52227587","0.51395243","0.5006331","0.49909642","0.4988925","0.49661958","0.49389002","0.49314305","0.49158552","0.489311","0.4870659","0.48248613","0.4814451","0.47850242","0.4669491","0.460155","0.4534467","0.45080948","0.4457423","0.44370884","0.4422073","0.44185385","0.4389394","0.43788794","0.43788794","0.4367516","0.4337832","0.4333366","0.42824373","0.4230762","0.4223108","0.42062724","0.41960654","0.41924712","0.4188309","0.4182805","0.4178869","0.41630977","0.41455168","0.41349036","0.4134411","0.4130284","0.4123733","0.41220903","0.41220903","0.41220903","0.41220903","0.41220903","0.41207165","0.40972254","0.40725318","0.40547365","0.40098023","0.40098023","0.40097553","0.40088606","0.40084383","0.4001109","0.39771184","0.3973389","0.39719763","0.39569956","0.39559147","0.39558843","0.3951964","0.39480346","0.39479208","0.3924251","0.38918343","0.3888049","0.38749003","0.38690695","0.3837693","0.38307288","0.38165268","0.38106614","0.38056853","0.3805351","0.38044527","0.3802506","0.3799369","0.37909785","0.3789393","0.37880144","0.37861595","0.3772584","0.37708822","0.37646344","0.37601322","0.37601322","0.37519556","0.37500468","0.37435102","0.37430814","0.37425143","0.37394613","0.3735129"],"string":"[\n \"0.6610284\",\n \"0.54055816\",\n \"0.53626394\",\n \"0.52227587\",\n \"0.51395243\",\n \"0.5006331\",\n \"0.49909642\",\n \"0.4988925\",\n \"0.49661958\",\n \"0.49389002\",\n \"0.49314305\",\n \"0.49158552\",\n \"0.489311\",\n \"0.4870659\",\n \"0.48248613\",\n \"0.4814451\",\n \"0.47850242\",\n \"0.4669491\",\n \"0.460155\",\n \"0.4534467\",\n \"0.45080948\",\n \"0.4457423\",\n \"0.44370884\",\n \"0.4422073\",\n \"0.44185385\",\n \"0.4389394\",\n \"0.43788794\",\n \"0.43788794\",\n \"0.4367516\",\n \"0.4337832\",\n \"0.4333366\",\n \"0.42824373\",\n \"0.4230762\",\n \"0.4223108\",\n \"0.42062724\",\n \"0.41960654\",\n \"0.41924712\",\n \"0.4188309\",\n \"0.4182805\",\n \"0.4178869\",\n \"0.41630977\",\n \"0.41455168\",\n \"0.41349036\",\n \"0.4134411\",\n \"0.4130284\",\n \"0.4123733\",\n \"0.41220903\",\n \"0.41220903\",\n \"0.41220903\",\n \"0.41220903\",\n \"0.41220903\",\n \"0.41207165\",\n \"0.40972254\",\n \"0.40725318\",\n \"0.40547365\",\n \"0.40098023\",\n \"0.40098023\",\n \"0.40097553\",\n \"0.40088606\",\n \"0.40084383\",\n \"0.4001109\",\n \"0.39771184\",\n \"0.3973389\",\n \"0.39719763\",\n \"0.39569956\",\n \"0.39559147\",\n \"0.39558843\",\n \"0.3951964\",\n \"0.39480346\",\n \"0.39479208\",\n \"0.3924251\",\n \"0.38918343\",\n \"0.3888049\",\n \"0.38749003\",\n \"0.38690695\",\n \"0.3837693\",\n \"0.38307288\",\n \"0.38165268\",\n \"0.38106614\",\n \"0.38056853\",\n \"0.3805351\",\n \"0.38044527\",\n \"0.3802506\",\n \"0.3799369\",\n \"0.37909785\",\n \"0.3789393\",\n \"0.37880144\",\n \"0.37861595\",\n \"0.3772584\",\n \"0.37708822\",\n \"0.37646344\",\n \"0.37601322\",\n \"0.37601322\",\n \"0.37519556\",\n \"0.37500468\",\n \"0.37435102\",\n \"0.37430814\",\n \"0.37425143\",\n \"0.37394613\",\n \"0.3735129\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8813465"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":24575,"cells":{"query":{"kind":"string","value":"Sets the hpkp of this TypesConsoleCertificateSettings."},"document":{"kind":"string","value":"def hpkp(self, hpkp):\n\n self._hpkp = hpkp"},"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 pssh(self, pssh):\n self._pssh = pssh\n return self","def hdp_version(self, hdp_version):\n\n self._hdp_version = hdp_version","def set_kp():\n kp = request.params.get(\"kp\", 0, type=float)\n pid = request.params.get(\"pid\", 1, type=int)\n retval = RP_LIB.rp_PIDSetKp(pid, ctypes.c_float(kp))\n if retval != 0:\n LOG.error(\"Failed to set PID Kp. Error code: %s\", ERROR_CODES[retval])\n LOG.info(\"Kp: %f\", kp)\n LOG.info(\"PID: %d\", pid)","def pthid(self, pthid):\n\n self._pthid = pthid","def setKp(self, proportional_gain):\n\t\tself.Kp = proportional_gain","def setKp(self, proportional_gain):\r\n self.Kp = proportional_gain","def setKp(self, proportional_gain):\n self.Kp = proportional_gain","def setKp(self, proportional_gain):\n self.__Kp = proportional_gain","def set_pubkey(self, pkey):\n assert m2.x509_type_check(self.x509), \"'x509' type error\"\n return m2.x509_set_pubkey(self.x509, pkey.pkey)","def hklout(self, hklout):\n self._hklout = hklout","def set_wpa(self, pardus_profile):\n\n self.key_mgmt = \"wpa-psk\"\n self.psk = str(pardus_profile.get_auth_password())","def setKp(self, proportional_gain):\r\n\t\tself.Kp = proportional_gain\r\n\t\tself.label = \"standard_PID_Controller/Kp=%f, Ti=%f, Td=%f\" % (self.Kp, self.Ti, self.Td)","def _set_set_dscp(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\"set-dscp\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=True)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"set_dscp must be of a type compatible with uint8\"\"\",\n 'defined-type': \"uint8\",\n 'generated-type': \"\"\"YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\"set-dscp\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=True)\"\"\",\n })\n\n self.__set_dscp = t\n if hasattr(self, '_set'):\n self._set()","def _set_set_dscp(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\"set-dscp\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=True)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"set_dscp must be of a type compatible with uint8\"\"\",\n 'defined-type': \"uint8\",\n 'generated-type': \"\"\"YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\"set-dscp\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=True)\"\"\",\n })\n\n self.__set_dscp = t\n if hasattr(self, '_set'):\n self._set()","def _set_set_dscp(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\"set-dscp\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=True)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"set_dscp must be of a type compatible with uint8\"\"\",\n 'defined-type': \"uint8\",\n 'generated-type': \"\"\"YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\"set-dscp\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=True)\"\"\",\n })\n\n self.__set_dscp = t\n if hasattr(self, '_set'):\n self._set()","def _set_set_dscp(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\"set-dscp\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=False)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"set_dscp must be of a type compatible with uint8\"\"\",\n 'defined-type': \"uint8\",\n 'generated-type': \"\"\"YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\"set-dscp\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=False)\"\"\",\n })\n\n self.__set_dscp = t\n if hasattr(self, '_set'):\n self._set()","def _set_set_dscp(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\"set-dscp\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=False)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"set_dscp must be of a type compatible with uint8\"\"\",\n 'defined-type': \"uint8\",\n 'generated-type': \"\"\"YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\"set-dscp\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=False)\"\"\",\n })\n\n self.__set_dscp = t\n if hasattr(self, '_set'):\n self._set()","def _set_set_dscp(self, v, load=False):\n if hasattr(v, \"_utype\"):\n v = v._utype(v)\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\"set-dscp\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=False)\n except (TypeError, ValueError):\n raise ValueError({\n 'error-string': \"\"\"set_dscp must be of a type compatible with uint8\"\"\",\n 'defined-type': \"uint8\",\n 'generated-type': \"\"\"YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\"set-dscp\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=False)\"\"\",\n })\n\n self.__set_dscp = t\n if hasattr(self, '_set'):\n self._set()","def __init__(self):\n super(sppasSymbolSettings, self).__init__()\n\n self.__dict__ = dict(\n unk=\"<UNK>\",\n phone=sppasSymbolSettings.__phone_symbols(),\n ortho=sppasSymbolSettings.__ortho_symbols(),\n all=sppasSymbolSettings.__all_symbols()\n )","def setHpr(self, hpr):\n self.cameraNode.setHpr(hpr)","def dhcp(self, dhcp):\n\n self._dhcp = dhcp","def set_wep(self, pardus_profile):\n\n self.auth_alg = \"open\" #TODO: or 'shared' ??\n self.key_mgmt = \"None\" # Which stands for WEP based key management\n self.wep_key0 = str(pardus_profile.get_auth_password()) # Default index\n self.wep_key_type = \"1\" # Interpret WEP keys as hex or ascii keys","def setHBin(self, hbin):\n with self.lock:\n self.hbin = hbin","def __init__(self, kippt):\n self.kippt = kippt","def h(self, h):\n\n self._h = h","def hklin(self, hklin):\n self._hklin = hklin","def set_primary_object_hash(self, hsh):\n self.hash = hsh","def _serverTLS13Handshake(self, settings, clientHello, cipherSuite,\n privateKey, serverCertChain, version, scheme,\n srv_alpns, reqCert):\n prf_name, prf_size = self._getPRFParams(cipherSuite)\n\n secret = bytearray(prf_size)\n\n share = clientHello.getExtension(ExtensionType.key_share)\n if share:\n share_ids = [i.group for i in share.client_shares]\n for group_name in chain(settings.keyShares, settings.eccCurves,\n settings.dhGroups):\n selected_group = getattr(GroupName, group_name)\n if selected_group in share_ids:\n cl_key_share = next(i for i in share.client_shares\n if i.group == selected_group)\n break\n else:\n for result in self._sendError(AlertDescription.internal_error,\n \"HRR did not work?!\"):\n yield result\n\n psk = None\n selected_psk = None\n resumed_client_cert_chain = None\n psks = clientHello.getExtension(ExtensionType.pre_shared_key)\n psk_types = clientHello.getExtension(\n ExtensionType.psk_key_exchange_modes)\n if psks and (PskKeyExchangeMode.psk_dhe_ke in psk_types.modes or\n PskKeyExchangeMode.psk_ke in psk_types.modes) and \\\n (settings.pskConfigs or settings.ticketKeys):\n for i, ident in enumerate(psks.identities):\n ticket = None\n external = True\n match = [j for j in settings.pskConfigs\n if j[0] == ident.identity]\n if not match:\n (match, ticket) = self._tryDecrypt(settings, ident)\n external = False\n if not match:\n continue\n match = [match]\n\n # check if PSK can be used with selected cipher suite\n psk_hash = match[0][2] if len(match[0]) > 2 else 'sha256'\n if psk_hash != prf_name:\n continue\n\n psk = match[0][1]\n selected_psk = i\n if ticket:\n resumed_client_cert_chain = ticket.client_cert_chain\n try:\n HandshakeHelpers.verify_binder(\n clientHello,\n self._pre_client_hello_handshake_hash,\n selected_psk,\n psk,\n psk_hash,\n external)\n except TLSIllegalParameterException as e:\n for result in self._sendError(\n AlertDescription.illegal_parameter,\n str(e)):\n yield result\n break\n\n sh_extensions = []\n\n # we need to gen key share either when we selected psk_dhe_ke or\n # regular certificate authenticated key exchange (the default)\n if (psk and\n PskKeyExchangeMode.psk_dhe_ke in psk_types.modes and\n \"psk_dhe_ke\" in settings.psk_modes) or\\\n (psk is None and privateKey):\n self.ecdhCurve = selected_group\n kex = self._getKEX(selected_group, version)\n key_share = self._genKeyShareEntry(selected_group, version)\n\n try:\n shared_sec = kex.calc_shared_key(key_share.private,\n cl_key_share.key_exchange)\n except TLSIllegalParameterException as alert:\n for result in self._sendError(\n AlertDescription.illegal_parameter,\n str(alert)):\n yield result\n\n sh_extensions.append(ServerKeyShareExtension().create(key_share))\n elif (psk is not None and\n PskKeyExchangeMode.psk_ke in psk_types.modes and\n \"psk_ke\" in settings.psk_modes):\n shared_sec = bytearray(prf_size)\n else:\n for result in self._sendError(\n AlertDescription.handshake_failure,\n \"Could not find acceptable PSK identity nor certificate\"):\n yield result\n\n if psk is None:\n psk = bytearray(prf_size)\n\n sh_extensions.append(SrvSupportedVersionsExtension().create(version))\n if selected_psk is not None:\n sh_extensions.append(SrvPreSharedKeyExtension()\n .create(selected_psk))\n\n serverHello = ServerHello()\n # in TLS1.3 the version selected is sent in extension, (3, 3) is\n # just dummy value to workaround broken middleboxes\n serverHello.create((3, 3), getRandomBytes(32),\n clientHello.session_id,\n cipherSuite, extensions=sh_extensions)\n\n msgs = []\n msgs.append(serverHello)\n if not self._ccs_sent and clientHello.session_id:\n ccs = ChangeCipherSpec().create()\n msgs.append(ccs)\n for result in self._sendMsgs(msgs):\n yield result\n\n # Early secret\n secret = secureHMAC(secret, psk, prf_name)\n\n # Handshake Secret\n secret = derive_secret(secret, bytearray(b'derived'), None, prf_name)\n secret = secureHMAC(secret, shared_sec, prf_name)\n\n sr_handshake_traffic_secret = derive_secret(secret,\n bytearray(b's hs traffic'),\n self._handshake_hash,\n prf_name)\n cl_handshake_traffic_secret = derive_secret(secret,\n bytearray(b'c hs traffic'),\n self._handshake_hash,\n prf_name)\n self.version = version\n self._recordLayer.calcTLS1_3PendingState(\n cipherSuite,\n cl_handshake_traffic_secret,\n sr_handshake_traffic_secret,\n settings.cipherImplementations)\n\n self._changeWriteState()\n\n ee_extensions = []\n\n if clientHello.getExtension(ExtensionType.record_size_limit) and \\\n settings.record_size_limit:\n ee_extensions.append(RecordSizeLimitExtension().create(\n min(2**14+1, settings.record_size_limit)))\n\n # a bit of a hack to detect if the HRR was sent\n # as that means that original key share didn't match what we wanted\n # send the client updated list of shares we support,\n # preferred ones first\n if clientHello.getExtension(ExtensionType.cookie):\n ext = SupportedGroupsExtension()\n groups = [getattr(GroupName, i) for i in settings.keyShares]\n groups += [getattr(GroupName, i) for i in settings.eccCurves\n if getattr(GroupName, i) not in groups]\n groups += [getattr(GroupName, i) for i in settings.dhGroups\n if getattr(GroupName, i) not in groups]\n if groups:\n ext.create(groups)\n ee_extensions.append(ext)\n\n alpn_ext = clientHello.getExtension(ExtensionType.alpn)\n if alpn_ext:\n # error handling was done when receiving ClientHello\n matched = [i for i in alpn_ext.protocol_names if i in srv_alpns]\n if matched:\n ext = ALPNExtension().create([matched[0]])\n ee_extensions.append(ext)\n\n if clientHello.getExtension(ExtensionType.heartbeat):\n if settings.use_heartbeat_extension:\n ee_extensions.append(HeartbeatExtension().create(\n HeartbeatMode.PEER_ALLOWED_TO_SEND))\n\n encryptedExtensions = EncryptedExtensions().create(ee_extensions)\n self._queue_message(encryptedExtensions)\n\n if selected_psk is None:\n\n # optionally send the client a certificate request\n if reqCert:\n\n # the context SHALL be zero length except in post-handshake\n ctx = b''\n\n # Get list of valid Signing Algorithms\n # we don't support DSA for client certificates yet\n cr_settings = settings.validate()\n cr_settings.dsaSigHashes = []\n valid_sig_algs = self._sigHashesToList(cr_settings)\n assert valid_sig_algs\n\n certificate_request = CertificateRequest(self.version)\n certificate_request.create(context=ctx, sig_algs=valid_sig_algs)\n self._queue_message(certificate_request)\n\n certificate = Certificate(CertificateType.x509, self.version)\n certificate.create(serverCertChain, bytearray())\n self._queue_message(certificate)\n\n certificate_verify = CertificateVerify(self.version)\n\n signature_scheme = getattr(SignatureScheme, scheme)\n\n signature_context = \\\n KeyExchange.calcVerifyBytes((3, 4), self._handshake_hash,\n signature_scheme, None, None, None,\n prf_name, b'server')\n\n if signature_scheme in (SignatureScheme.ed25519,\n SignatureScheme.ed448):\n hashName = \"intrinsic\"\n padType = None\n saltLen = None\n sig_func = privateKey.hashAndSign\n ver_func = privateKey.hashAndVerify\n elif signature_scheme[1] == SignatureAlgorithm.ecdsa:\n hashName = HashAlgorithm.toRepr(signature_scheme[0])\n padType = None\n saltLen = None\n sig_func = privateKey.sign\n ver_func = privateKey.verify\n else:\n padType = SignatureScheme.getPadding(scheme)\n hashName = SignatureScheme.getHash(scheme)\n saltLen = getattr(hashlib, hashName)().digest_size\n sig_func = privateKey.sign\n ver_func = privateKey.verify\n\n signature = sig_func(signature_context,\n padType,\n hashName,\n saltLen)\n if not ver_func(signature, signature_context,\n padType,\n hashName,\n saltLen):\n for result in self._sendError(\n AlertDescription.internal_error,\n \"Certificate Verify signature failed\"):\n yield result\n certificate_verify.create(signature, signature_scheme)\n\n self._queue_message(certificate_verify)\n\n finished_key = HKDF_expand_label(sr_handshake_traffic_secret,\n b\"finished\", b'', prf_size, prf_name)\n verify_data = secureHMAC(finished_key,\n self._handshake_hash.digest(prf_name),\n prf_name)\n\n finished = Finished(self.version, prf_size).create(verify_data)\n\n self._queue_message(finished)\n for result in self._queue_flush():\n yield result\n\n self._changeReadState()\n\n # Master secret\n secret = derive_secret(secret, bytearray(b'derived'), None, prf_name)\n secret = secureHMAC(secret, bytearray(prf_size), prf_name)\n\n cl_app_traffic = derive_secret(secret, bytearray(b'c ap traffic'),\n self._handshake_hash, prf_name)\n sr_app_traffic = derive_secret(secret, bytearray(b's ap traffic'),\n self._handshake_hash, prf_name)\n self._recordLayer.calcTLS1_3PendingState(serverHello.cipher_suite,\n cl_app_traffic,\n sr_app_traffic,\n settings\n .cipherImplementations)\n\n # all the messages sent by the server after the Finished message\n # MUST be encrypted with ap traffic secret, even if they regard\n # problems in processing client Certificate, CertificateVerify or\n # Finished messages\n self._changeWriteState()\n\n client_cert_chain = None\n #Get [Certificate,] (if was requested)\n if reqCert and selected_psk is None:\n for result in self._getMsg(ContentType.handshake,\n HandshakeType.certificate,\n CertificateType.x509):\n if result in (0, 1):\n yield result\n else:\n break\n client_certificate = result\n assert isinstance(client_certificate, Certificate)\n client_cert_chain = client_certificate.cert_chain\n\n #Get and check CertificateVerify, if relevant\n cli_cert_verify_hh = self._handshake_hash.copy()\n if client_cert_chain and client_cert_chain.getNumCerts():\n for result in self._getMsg(ContentType.handshake,\n HandshakeType.certificate_verify):\n if result in (0, 1):\n yield result\n else: break\n certificate_verify = result\n assert isinstance(certificate_verify, CertificateVerify)\n\n signature_scheme = certificate_verify.signatureAlgorithm\n\n valid_sig_algs = self._sigHashesToList(settings,\n certList=client_cert_chain,\n version=(3, 4))\n if signature_scheme not in valid_sig_algs:\n for result in self._sendError(\n AlertDescription.illegal_parameter,\n \"Invalid signature on Certificate Verify\"):\n yield result\n\n signature_context = \\\n KeyExchange.calcVerifyBytes((3, 4), cli_cert_verify_hh,\n signature_scheme, None, None, None,\n prf_name, b'client')\n\n public_key = client_cert_chain.getEndEntityPublicKey()\n\n if signature_scheme in (SignatureScheme.ed25519,\n SignatureScheme.ed448):\n hash_name = \"intrinsic\"\n pad_type = None\n salt_len = None\n ver_func = public_key.hashAndVerify\n elif signature_scheme[1] == SignatureAlgorithm.ecdsa:\n hash_name = HashAlgorithm.toRepr(signature_scheme[0])\n pad_type = None\n salt_len = None\n ver_func = public_key.verify\n else:\n scheme = SignatureScheme.toRepr(signature_scheme)\n pad_type = SignatureScheme.getPadding(scheme)\n hash_name = SignatureScheme.getHash(scheme)\n salt_len = getattr(hashlib, hash_name)().digest_size\n ver_func = public_key.verify\n\n if not ver_func(certificate_verify.signature,\n signature_context,\n pad_type,\n hash_name,\n salt_len):\n for result in self._sendError(\n AlertDescription.decrypt_error,\n \"signature verification failed\"):\n yield result\n\n # as both exporter and resumption master secrets include handshake\n # transcript, we need to derive them early\n exporter_master_secret = derive_secret(secret,\n bytearray(b'exp master'),\n self._handshake_hash,\n prf_name)\n\n # verify Finished of client\n cl_finished_key = HKDF_expand_label(cl_handshake_traffic_secret,\n b\"finished\", b'',\n prf_size, prf_name)\n cl_verify_data = secureHMAC(cl_finished_key,\n self._handshake_hash.digest(prf_name),\n prf_name)\n for result in self._getMsg(ContentType.handshake,\n HandshakeType.finished,\n prf_size):\n if result in (0, 1):\n yield result\n else:\n break\n cl_finished = result\n assert isinstance(cl_finished, Finished)\n if cl_finished.verify_data != cl_verify_data:\n for result in self._sendError(\n AlertDescription.decrypt_error,\n \"Finished value is not valid\"):\n yield result\n\n # disallow CCS messages after handshake\n self._middlebox_compat_mode = False\n\n resumption_master_secret = derive_secret(secret,\n bytearray(b'res master'),\n self._handshake_hash,\n prf_name)\n\n self._first_handshake_hashes = self._handshake_hash.copy()\n\n self.session = Session()\n self.extendedMasterSecret = True\n server_name = None\n if clientHello.server_name:\n server_name = clientHello.server_name.decode('utf-8')\n\n app_proto = None\n alpnExt = encryptedExtensions.getExtension(ExtensionType.alpn)\n if alpnExt:\n app_proto = alpnExt.protocol_names[0]\n\n if not client_cert_chain and resumed_client_cert_chain:\n client_cert_chain = resumed_client_cert_chain\n\n self.session.create(secret,\n bytearray(b''), # no session_id\n serverHello.cipher_suite,\n bytearray(b''), # no SRP\n client_cert_chain,\n serverCertChain,\n None,\n False,\n server_name,\n encryptThenMAC=False,\n extendedMasterSecret=True,\n appProto=app_proto,\n cl_app_secret=cl_app_traffic,\n sr_app_secret=sr_app_traffic,\n exporterMasterSecret=exporter_master_secret,\n resumptionMasterSecret=resumption_master_secret,\n # NOTE it must be a reference, not a copy\n tickets=self.tickets)\n\n # switch to application_traffic_secret for client packets\n self._changeReadState()\n\n for result in self._serverSendTickets(settings):\n yield result\n\n yield \"finished\"","def vscp_pythia_configure(self):\n vscp_pythia_configure = self._lib.vscp_pythia_configure\n vscp_pythia_configure.argtypes = []\n vscp_pythia_configure.restype = c_int\n return vscp_pythia_configure()","def set_pubkey(self, pkey):\n return m2.x509_req_set_pubkey(self.req, pkey.pkey)","def _init_key_settings(self):\n self.minKeySize = 1023\n self.maxKeySize = 8193\n self.rsaSigHashes = list(RSA_SIGNATURE_HASHES)\n self.rsaSchemes = list(RSA_SCHEMES)\n self.dsaSigHashes = list(DSA_SIGNATURE_HASHES)\n self.virtual_hosts = []\n # DH key settings\n self.eccCurves = list(CURVE_NAMES)\n self.dhParams = None\n self.dhGroups = list(ALL_DH_GROUP_NAMES)\n self.defaultCurve = \"secp256r1\"\n self.keyShares = [\"secp256r1\", \"x25519\"]\n self.padding_cb = None\n self.use_heartbeat_extension = True\n self.heartbeat_response_callback = None","def test_set_public_key_setter(self) -> None:\n\n expected = self.pem_public_key.decode()\n\n encryptor = DataEncryption()\n encryptor.set_public_key(self.pem_public_key)\n\n # pylint: disable=protected-access\n actual = encryptor._loaded_public_key.public_bytes(\n serialization.Encoding.PEM, serialization.PublicFormat.PKCS1\n ).decode()\n\n self.assertEqual(expected, actual)","def Host(self, h):\r\n\r\n self.host = h\r\n return self","def SetPreference(self, preferenceKey, value):\r\n\r\n config = self.GetConfig()\r\n config.Write(preferenceKey, str(value))\r\n config.Flush()","def set_phs(self):\n return 'phs{:06}'.format(self.i_accession)","def __init__(self):\n super(sppasSeparatorSettings, self).__init__()\n self.__dict__ = dict(\n phonemes=\"-\", # X-SAMPA standard\n syllables=\".\", # X-SAMPA standard\n variants=\"|\" # used for all alternative tags\n )","def setup_keys(self, dh_object, public_key, private_key):\n public_numbers = DHPublicNumbers(public_key, dh_object.parameter_numbers)\n private_numbers = DHPrivateNumbers(private_key, public_numbers)\n dh_object.private_key = private_numbers.private_key(default_backend())","def setTopP(self, value):\n return self._set(topP=value)","def setTopP(self, value):\n return self._set(topP=value)","def setTopP(self, value):\n return self._set(topP=value)","def p2pkh(btcAddress):\n ret = CScript([OP_DUP, OP_HASH160, bitcoinAddress2bin(btcAddress), OP_EQUALVERIFY, OP_CHECKSIG])\n return ret","def set_hp_properties(self, name, hp_type=None, scale=None):\n hp_list = [hp for hp in self.hyper_params if hp.name == name]\n assert len(hp_list) == 1\n hp = hp_list[0]\n assert isinstance(hp, HyperParameter)\n if hp.hp_type is None: hp.hp_type = hp_type\n if hp.scale is None: hp.scale = scale","def plogi_settings(self, plogi_settings):\n\n self._plogi_settings = plogi_settings","def psid(self, psid):\n\n self._psid = psid","def set_pno(self, pno):\n self.__pno = pno","def preference(self, preference):\n\n self._preference = preference","def setPassphrase( self , passphrase ):\n\t\tself.passphrase\t= passphrase\n\t\t\n\t\t# Generate and log the generated PMK.\n\t\tself.PMK = pbkdf2_bin( self.passphrase , self.ssid , 4096 , 32 )\n\t\tself.logger.logKey( 'Pairwise Master Key' , self.PMK )","def set_haiku(self, haiku):\n self.haiku = haiku","def svn_client_ctx_t_config_set(svn_client_ctx_t_self, apr_hash_t_config): # real signature unknown; restored from __doc__\n pass","def set_hsdsch_mpo(self, carrier, control=\"AUTO\", pwrOffsetManual=\"\"):\r\r\n self.write('CONFigure:WCDMa:SIGN:DL:CARRier%s:ENHanced:HSPDsch:POFFset %s'\r\r\n %(carrier, control))","def set_configure_with_dhcp(self, bConfigureWithDhcp):\n\t\tcall_sdk_function('PrlVmDevNet_SetConfigureWithDhcp', self.handle, bConfigureWithDhcp)","def set_counter_based_otp(self, otp_passcode: str):\n self._hotp = HOTP(otp_passcode)","def set_hbond(self) -> None:\n ...","def hypertension(self, hypertension):\n\n self.logger.debug(\"In 'hypertension' setter.\")\n\n self._hypertension = hypertension","def set_haproxy(self):\n logging.info('currently only haproxy is supported for load balancing')\n self.inventory_dict['csah']['vars']['proxy'] = 'haproxy'\n self.inventory_dict['csah']['vars']['haproxy_conf'] = '/etc/haproxy/haproxy.cfg'\n self.inventory_dict['csah']['vars']['master_ports'] = [{'port': 6443, 'description': 'apiserver'},\n {'port': 22623 , 'description': 'configserver'}]\n self.inventory_dict['csah']['vars']['worker_ports'] = [{'port': 80, 'description': 'http'},\n {'port': 443, 'description': 'https'}]","def host_option(self, host_option):\n allowed_values = [\"admin_only\", \"player\", \"non_player\"]\n if host_option not in allowed_values:\n raise ValueError(\n \"Invalid value for `host_option` ({0}), must be one of {1}\"\n .format(host_option, allowed_values)\n )\n\n self._host_option = host_option","def __init__(self):\n super(sppasPathSettings, self).__init__()\n\n sppas_dir = os.path.dirname(os.path.dirname(\n os.path.dirname(os.path.abspath(__file__))))\n\n self.__dict__ = dict(\n sppas=sppas_dir,\n cli=os.path.join(sppas_dir, \"bin\"),\n etc=os.path.join(sppas_dir, \"etc\"),\n po=os.path.join(sppas_dir, \"po\"),\n src=os.path.join(sppas_dir, \"src\"),\n plugins=os.path.join(os.path.dirname(sppas_dir), \"plugins\"),\n resources=os.path.join(os.path.dirname(sppas_dir), \"resources\"),\n samples=os.path.join(os.path.dirname(sppas_dir), \"samples\"),\n logs=os.path.join(os.path.dirname(sppas_dir), \".logs\"),\n wkps=os.path.join(os.path.dirname(sppas_dir), \"workspaces\"),\n trash=os.path.join(os.path.dirname(sppas_dir), \".trash\"),\n )","def setPreferences(self, key, value):\n Preferences.Prefs.settings.setValue(\n self.PreferencesKey + \"/\" + key, value)\n \n if key in [\"VirtualEnvironmentPy2\", \"VirtualEnvironmentPy3\"]:\n self.__reregisterProjectType()\n elif key == \"TranslationsEditor\":\n if self.__object:\n self.__object.registerOpenHook()","def _AddPerInstanceSshkey(self):\n if self._ssh_public_key_path:\n rsa = self._LoadSshPublicKey(self._ssh_public_key_path)\n logger.info(\"ssh_public_key_path is specified in config: %s, \"\n \"will add the key to the instance.\",\n self._ssh_public_key_path)\n self._metadata[\"sshKeys\"] = \"{0}:{2}\\n{1}:{2}\".format(getpass.getuser(),\n constants.GCE_USER,\n rsa)\n else:\n logger.warning(\n \"ssh_public_key_path is not specified in config, \"\n \"only project-wide key will be effective.\")","def configure_stp_instance(self, instance, **kwargs):\n pass","def load_keypass_options(subcmd, pfx):\n\n keypass_grp = subcmd.add_argument_group('Key / Password Select')\n\n kpg = keypass_grp.add_mutually_exclusive_group(required=True)\n\n kpg.add_argument(\n '--use-key', action='store_true', dest='use_key',\n help='enables usage of key for {}cryption - enter key in secure prompt or specify file with -i'.format(pfx))\n\n kpg.add_argument(\n '--use-pw', action='store_true', dest='use_pw',\n help='enables usage of password, salt, iterations for {}cryption - enter pw in secure prompt or specify file with -i'.format(pfx))\n\n load_pw_options(subcmd)","def preference(self, key, value):\n self.command(\"preference %(key)s %(value)s\" % locals())","def dhcp_options_id(self, dhcp_options_id):\n self._dhcp_options_id = dhcp_options_id","def setPIDSourceType(self, pidSource: PIDSourceType) -> None:\n self.pidSource = ...","def set_totp(self, totp_secret):\n self.totp = TOTP(totp_secret)\n return self","def _wrap_publickey(self) -> None:\n p_der = ffi.new(\"unsigned char **\")\n der_len = lib.i2d_PublicKey(self._pkey, p_der)\n if der_len < 0:\n raise InvalidPKeyError(\"Could not serialize public key\")\n try:\n der = ffi.buffer(p_der[0], der_len)[:]\n try:\n self._key = load_der_public_key(der, backend=default_backend())\n except ValueError as exc:\n raise InvalidPKeyError from exc\n finally:\n lib.OPENSSL_free(p_der[0])","def privacy_protocol(self, privacy_protocol):\n\n self._privacy_protocol = privacy_protocol","def setKey(self, *args):\n return _libsbml.ConversionOption_setKey(self, *args)","def SetOutput(self, output: 'itkPointSetSS2') -> \"void\":\n return _itkMeshSourcePython.itkMeshSourcePSSS2_SetOutput(self, output)","def pkey(self) -> ffi.CType:\n return self._pkey","def setCryptographicHandlers( self , tkip = None , aes = None ):\n\t\tself.handleTKIP = tkip\n\t\tself.handleAES \t= aes","def setSignPDF(self, keystoreURL, keyAlias, keystorePassword, keystoreType, signingMode):\n self.PDFreactorConfiguration.in1[\"signPdfKeystoreURL\"] = keystoreURL\n self.PDFreactorConfiguration.in1[\"signPdfKeyAlias\"] = keyAlias\n self.PDFreactorConfiguration.in1[\"signPdfKeystorePassword\"] = keystorePassword\n self.PDFreactorConfiguration.in1[\"signPdfKeystoreType\"] = keystoreType\n self.PDFreactorConfiguration.in1[\"signPdfSigningMode\"] = signingMode","def load_key(self, pemfile_path_abs: str, set_priv=False) -> None:\n return None","def hyperlipidemia(self, hyperlipidemia):\n\n self.logger.debug(\"In 'hyperlipidemia' setter.\")\n\n self._hyperlipidemia = hyperlipidemia","def load_xonsh_bindings(ptk_bindings: KeyBindingsBase) -> KeyBindingsBase:\n key_bindings = KeyBindings()\n handle = key_bindings.add\n has_selection = HasSelection()\n insert_mode = ViInsertMode() | EmacsInsertMode()\n\n if XSH.env[\"XONSH_CTRL_BKSP_DELETION\"]:\n # Not all terminal emulators emit the same keys for backspace, therefore\n # ptk always maps backspace (\"\\x7f\") to ^H (\"\\x08\"), and all the backspace bindings are registered for ^H.\n # This means we can't re-map backspace and instead we register a new \"real-ctrl-bksp\" key.\n # See https://github.com/xonsh/xonsh/issues/4407\n\n if ON_WINDOWS:\n # On windows BKSP is \"\\x08\" and CTRL-BKSP is \"\\x7f\"\n REAL_CTRL_BKSP = \"\\x7f\"\n\n # PTK uses a second mapping\n from prompt_toolkit.input import win32 as ptk_win32\n\n ptk_win32.ConsoleInputReader.mappings[b\"\\x7f\"] = REAL_CTRL_BKSP # type: ignore\n else:\n REAL_CTRL_BKSP = \"\\x08\"\n\n # Prompt-toolkit allows using single-character keys that aren't in the `Keys` enum.\n ansi_escape_sequences.ANSI_SEQUENCES[REAL_CTRL_BKSP] = REAL_CTRL_BKSP # type: ignore\n ansi_escape_sequences.REVERSE_ANSI_SEQUENCES[REAL_CTRL_BKSP] = REAL_CTRL_BKSP # type: ignore\n\n @handle(REAL_CTRL_BKSP, filter=insert_mode)\n def delete_word(event):\n \"\"\"Delete a single word (like ALT-backspace)\"\"\"\n get_by_name(\"backward-kill-word\").call(event)\n\n @handle(Keys.Tab, filter=tab_insert_indent)\n def insert_indent(event):\n \"\"\"\n If there are only whitespaces before current cursor position insert\n indent instead of autocompleting.\n \"\"\"\n env = XSH.env\n event.cli.current_buffer.insert_text(env.get(\"INDENT\"))\n\n @handle(Keys.Tab, filter=~tab_insert_indent & tab_menu_complete)\n def menu_complete_select(event):\n \"\"\"Start completion in menu-complete mode, or tab to next completion\"\"\"\n b = event.current_buffer\n if b.complete_state:\n b.complete_next()\n else:\n b.start_completion(select_first=True)\n\n @handle(Keys.ControlX, Keys.ControlE, filter=~has_selection)\n def open_editor(event):\n \"\"\"Open current buffer in editor\"\"\"\n event.current_buffer.open_in_editor(event.cli)\n\n @handle(Keys.BackTab, filter=insert_mode)\n def insert_literal_tab(event):\n \"\"\"Insert literal tab on Shift+Tab instead of autocompleting\"\"\"\n b = event.current_buffer\n if b.complete_state:\n b.complete_previous()\n else:\n env = XSH.env\n event.cli.current_buffer.insert_text(env.get(\"INDENT\"))\n\n def generate_parens_handlers(left, right):\n @handle(left, filter=autopair_condition)\n def insert_left_paren(event):\n buffer = event.cli.current_buffer\n\n if has_selection():\n wrap_selection(buffer, left, right)\n elif whitespace_or_bracket_after():\n buffer.insert_text(left)\n buffer.insert_text(right, move_cursor=False)\n else:\n buffer.insert_text(left)\n\n @handle(right, filter=autopair_condition)\n def overwrite_right_paren(event):\n buffer = event.cli.current_buffer\n\n if buffer.document.current_char == right:\n buffer.cursor_position += 1\n else:\n buffer.insert_text(right)\n\n generate_parens_handlers(\"(\", \")\")\n generate_parens_handlers(\"[\", \"]\")\n generate_parens_handlers(\"{\", \"}\")\n\n def generate_quote_handler(quote):\n @handle(quote, filter=autopair_condition)\n def insert_quote(event):\n buffer = event.cli.current_buffer\n\n if has_selection():\n wrap_selection(buffer, quote, quote)\n elif buffer.document.current_char == quote:\n buffer.cursor_position += 1\n elif whitespace_or_bracket_before() and whitespace_or_bracket_after():\n buffer.insert_text(quote)\n buffer.insert_text(quote, move_cursor=False)\n else:\n buffer.insert_text(quote)\n\n generate_quote_handler(\"'\")\n generate_quote_handler('\"')\n\n @handle(Keys.Backspace, filter=autopair_condition)\n def delete_brackets_or_quotes(event):\n \"\"\"Delete empty pair of brackets or quotes\"\"\"\n buffer = event.cli.current_buffer\n before = buffer.document.char_before_cursor\n after = buffer.document.current_char\n\n if any(\n [before == b and after == a for (b, a) in [\"()\", \"[]\", \"{}\", \"''\", '\"\"']]\n ):\n buffer.delete(1)\n\n buffer.delete_before_cursor(1)\n\n @handle(Keys.ControlD, filter=ctrl_d_condition)\n def call_exit_alias(event):\n \"\"\"Use xonsh exit function\"\"\"\n b = event.cli.current_buffer\n b.validate_and_handle()\n xonsh_exit([])\n\n @handle(Keys.ControlJ, filter=IsMultiline() & insert_mode)\n @handle(Keys.ControlM, filter=IsMultiline() & insert_mode)\n def multiline_carriage_return(event):\n \"\"\"Wrapper around carriage_return multiline parser\"\"\"\n b = event.cli.current_buffer\n carriage_return(b, event.cli)\n\n @handle(Keys.ControlJ, filter=should_confirm_completion)\n @handle(Keys.ControlM, filter=should_confirm_completion)\n def enter_confirm_completion(event):\n \"\"\"Ignore <enter> (confirm completion)\"\"\"\n event.current_buffer.complete_state = None\n\n @handle(Keys.Escape, filter=should_confirm_completion)\n def esc_cancel_completion(event):\n \"\"\"Use <ESC> to cancel completion\"\"\"\n event.cli.current_buffer.cancel_completion()\n\n @handle(Keys.Escape, Keys.ControlJ)\n def execute_block_now(event):\n \"\"\"Execute a block of text irrespective of cursor position\"\"\"\n b = event.cli.current_buffer\n b.validate_and_handle()\n\n @handle(Keys.Left, filter=beginning_of_line)\n def wrap_cursor_back(event):\n \"\"\"Move cursor to end of previous line unless at beginning of\n document\n \"\"\"\n b = event.cli.current_buffer\n b.cursor_up(count=1)\n relative_end_index = b.document.get_end_of_line_position()\n b.cursor_right(count=relative_end_index)\n\n @handle(Keys.Right, filter=end_of_line)\n def wrap_cursor_forward(event):\n \"\"\"Move cursor to beginning of next line unless at end of document\"\"\"\n b = event.cli.current_buffer\n relative_begin_index = b.document.get_start_of_line_position()\n b.cursor_left(count=abs(relative_begin_index))\n b.cursor_down(count=1)\n\n @handle(Keys.ControlM, filter=IsSearching())\n @handle(Keys.ControlJ, filter=IsSearching())\n def accept_search(event):\n search.accept_search()\n\n @handle(Keys.ControlZ)\n def skip_control_z(event):\n \"\"\"Prevents the writing of ^Z to the prompt, if Ctrl+Z was pressed\n during the previous command.\n \"\"\"\n pass\n\n @handle(Keys.ControlX, Keys.ControlX, filter=has_selection)\n def _cut(event):\n \"\"\"Cut selected text.\"\"\"\n data = event.current_buffer.cut_selection()\n event.app.clipboard.set_data(data)\n\n @handle(Keys.ControlX, Keys.ControlC, filter=has_selection)\n def _copy(event):\n \"\"\"Copy selected text.\"\"\"\n data = event.current_buffer.copy_selection()\n event.app.clipboard.set_data(data)\n\n @handle(Keys.ControlV, filter=insert_mode | has_selection)\n def _yank(event):\n \"\"\"Paste selected text.\"\"\"\n buff = event.current_buffer\n if buff.selection_state:\n buff.cut_selection()\n get_by_name(\"yank\").call(event)\n\n def create_alias(new_keys, original_keys):\n bindings = ptk_bindings.get_bindings_for_keys(tuple(original_keys))\n for original_binding in bindings:\n handle(*new_keys, filter=original_binding.filter)(original_binding.handler)\n\n # Complete a single auto-suggestion word\n create_alias([Keys.ControlRight], [\"escape\", \"f\"])\n\n # since macOS uses Control as reserved, then we use the alt/option key instead\n # which is mapped as the \"escape\" key\n create_alias([\"escape\", \"right\"], [\"escape\", \"f\"])\n\n return key_bindings","def set_field(self,Hext):\n self.raw_parameters[\"Hext\"] = Hext\n self.parameters = NormalizedParameters(self.raw_parameters)\n self._load()","def addPHTitration(default_pH_titration=(0,16,0.25)):\n \n parser.add_option(\"-P\",\"--pH-titration\",action=\"store\",type=\"float\",\n dest=\"pHtitr\",nargs=3,\n help=\"pH titration for UHBD calculations. PHTITR is a \\\n set of three values PH_START PH_STOP PH_INTERVAL. \\\n (Default 0 16 0.25)\",\n default=default_pH_titration)","def is_pkh(v) -> bool:\n try:\n validate_pkh(v)\n except (ValueError, TypeError):\n return False\n return True","def hive_options(self, hive_options):\n self._hive_options = hive_options","def _set_hop_id(self, v, load=False):\n parent = getattr(self, \"_parent\", None)\n if parent is not None and load is False:\n raise AttributeError(\"Cannot set keys directly when\" +\n \" within an instantiated list\")\n\n try:\n t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name=\"hop-id\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True)\n except (TypeError, ValueError):\n raise ValueError(\"\"\"hop_id must be of a type compatible with base=unicode, is_leaf=True, yang_name=\"hop-id\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True\"\"\")\n self.__hop_id = t\n if hasattr(self, '_set'):\n self._set()","def response_host(self, response_host):\n\n self._response_host = response_host","def response_host(self, response_host):\n\n self._response_host = response_host","def host_ip(self, host_ip):\n\n self._host_ip = host_ip","def writeto(self,output_file,**kwargs):\n dump_pkl(self._properties,output_file,**kwargs)\n return","def __init__(__self__, *,\n gcp_kms_encryption_key: Optional[pulumi.Input[str]] = None):\n if gcp_kms_encryption_key is not None:\n pulumi.set(__self__, \"gcp_kms_encryption_key\", gcp_kms_encryption_key)","def set_pid(self, kp=None, ki=None, kd=None):\n if kp is not None:\n self.k_p = kp\n if ki is not None:\n self.k_i = ki\n if kd is not None:\n self.k_d = kd\n\n self.reset_sum()","def __init__(self, printer):\n super(PowershellParentEnvironment, self).__init__()\n self._printer = printer","def __init__(__self__, *,\n id: pulumi.Input[str],\n public_signing_key: pulumi.Input[str],\n signing_certificate_thumbprint: Optional[pulumi.Input[str]] = None):\n pulumi.set(__self__, \"id\", id)\n pulumi.set(__self__, \"public_signing_key\", public_signing_key)\n if signing_certificate_thumbprint is not None:\n pulumi.set(__self__, \"signing_certificate_thumbprint\", signing_certificate_thumbprint)","def _set_propreties(self):\n pass","def post_process(self, packet: 'dict[str, Any]') -> 'SMFIdentificationBasedDPDOption':\n ret = super().post_process(packet) # type: SMFIdentificationBasedDPDOption\n ret.mode = Enum_SMFDPDMode.H_DPD\n return ret","def set_ip(self, ip: str, host_addr: str) -> None:\n self.config[\"linkIp\"] = ip\n self.config[\"ngapIp\"] = ip\n self.config[\"gtpIp\"] = ip","def set_options(self, kvlist):\r\n if not kvlist:\r\n return\r\n msg = \" \".join([\"%s=\\\"%s\\\"\"%(k,quote(v)) for k,v in kvlist])\r\n return self.sendAndRecv(\"SETCONF %s\\r\\n\"%msg)","def set_extensions_to_default(self):\n if self.cert_type is SSHCertificateType.USER:\n self.extensions = {'permit-X11-forwarding',\n 'permit-agent-forwarding',\n 'permit-port-forwarding',\n 'permit-pty', 'permit-user-rc'}\n else:\n # SSHCertificateType.HOST has no applicable extensions.\n self.clear_extensions()","def __init__(__self__, *,\n public_keys: Optional[pulumi.Input[Sequence[pulumi.Input['LinuxProfilePropertiesPublicKeysArgs']]]] = None):\n if public_keys is not None:\n pulumi.set(__self__, \"public_keys\", public_keys)","def public_key(self, public_key):\n self._public_key = public_key\n return self","def pvd(self, pvd):\n\n self.logger.debug(\"In 'pvd' setter.\")\n\n self._pvd = pvd","def setUp(self):\n\n self.private_key = self.get_new_key()\n self.public_key = self.private_key.public_key()\n\n self.pem_private_key = self.private_key.private_bytes(\n serialization.Encoding.PEM,\n serialization.PrivateFormat.PKCS8,\n serialization.NoEncryption(),\n )\n self.encrypted_pem_private_key = self.private_key.private_bytes(\n serialization.Encoding.PEM,\n serialization.PrivateFormat.PKCS8,\n serialization.BestAvailableEncryption(self.private_key_password),\n )\n\n self.pem_public_key = self.public_key.public_bytes(\n serialization.Encoding.PEM, serialization.PublicFormat.PKCS1\n )","def set_config(self, hVmCfg):\n\t\tcall_sdk_function('PrlVm_SetConfig', self.handle, conv_handle_arg(hVmCfg))","def h_27(options,buildout):\n h(options, buildout, '27', options['configure-options'])","def work_hours_setting(self, work_hours_setting):\n\n self._work_hours_setting = work_hours_setting"],"string":"[\n \"def pssh(self, pssh):\\n self._pssh = pssh\\n return self\",\n \"def hdp_version(self, hdp_version):\\n\\n self._hdp_version = hdp_version\",\n \"def set_kp():\\n kp = request.params.get(\\\"kp\\\", 0, type=float)\\n pid = request.params.get(\\\"pid\\\", 1, type=int)\\n retval = RP_LIB.rp_PIDSetKp(pid, ctypes.c_float(kp))\\n if retval != 0:\\n LOG.error(\\\"Failed to set PID Kp. Error code: %s\\\", ERROR_CODES[retval])\\n LOG.info(\\\"Kp: %f\\\", kp)\\n LOG.info(\\\"PID: %d\\\", pid)\",\n \"def pthid(self, pthid):\\n\\n self._pthid = pthid\",\n \"def setKp(self, proportional_gain):\\n\\t\\tself.Kp = proportional_gain\",\n \"def setKp(self, proportional_gain):\\r\\n self.Kp = proportional_gain\",\n \"def setKp(self, proportional_gain):\\n self.Kp = proportional_gain\",\n \"def setKp(self, proportional_gain):\\n self.__Kp = proportional_gain\",\n \"def set_pubkey(self, pkey):\\n assert m2.x509_type_check(self.x509), \\\"'x509' type error\\\"\\n return m2.x509_set_pubkey(self.x509, pkey.pkey)\",\n \"def hklout(self, hklout):\\n self._hklout = hklout\",\n \"def set_wpa(self, pardus_profile):\\n\\n self.key_mgmt = \\\"wpa-psk\\\"\\n self.psk = str(pardus_profile.get_auth_password())\",\n \"def setKp(self, proportional_gain):\\r\\n\\t\\tself.Kp = proportional_gain\\r\\n\\t\\tself.label = \\\"standard_PID_Controller/Kp=%f, Ti=%f, Td=%f\\\" % (self.Kp, self.Ti, self.Td)\",\n \"def _set_set_dscp(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\\\"set-dscp\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=True)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"set_dscp must be of a type compatible with uint8\\\"\\\"\\\",\\n 'defined-type': \\\"uint8\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\\\"set-dscp\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=True)\\\"\\\"\\\",\\n })\\n\\n self.__set_dscp = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def _set_set_dscp(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\\\"set-dscp\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=True)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"set_dscp must be of a type compatible with uint8\\\"\\\"\\\",\\n 'defined-type': \\\"uint8\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\\\"set-dscp\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=True)\\\"\\\"\\\",\\n })\\n\\n self.__set_dscp = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def _set_set_dscp(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\\\"set-dscp\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=True)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"set_dscp must be of a type compatible with uint8\\\"\\\"\\\",\\n 'defined-type': \\\"uint8\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\\\"set-dscp\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=True)\\\"\\\"\\\",\\n })\\n\\n self.__set_dscp = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def _set_set_dscp(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\\\"set-dscp\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=False)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"set_dscp must be of a type compatible with uint8\\\"\\\"\\\",\\n 'defined-type': \\\"uint8\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\\\"set-dscp\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=False)\\\"\\\"\\\",\\n })\\n\\n self.__set_dscp = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def _set_set_dscp(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\\\"set-dscp\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=False)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"set_dscp must be of a type compatible with uint8\\\"\\\"\\\",\\n 'defined-type': \\\"uint8\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\\\"set-dscp\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=False)\\\"\\\"\\\",\\n })\\n\\n self.__set_dscp = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def _set_set_dscp(self, v, load=False):\\n if hasattr(v, \\\"_utype\\\"):\\n v = v._utype(v)\\n try:\\n t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\\\"set-dscp\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=False)\\n except (TypeError, ValueError):\\n raise ValueError({\\n 'error-string': \\\"\\\"\\\"set_dscp must be of a type compatible with uint8\\\"\\\"\\\",\\n 'defined-type': \\\"uint8\\\",\\n 'generated-type': \\\"\\\"\\\"YANGDynClass(base=RestrictedClassType(base_type=int, restriction_dict={'range': ['0..255']}, int_size=8), is_leaf=True, yang_name=\\\"set-dscp\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='http://openconfig.net/yang/qos', defining_module='openconfig-qos', yang_type='uint8', is_config=False)\\\"\\\"\\\",\\n })\\n\\n self.__set_dscp = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def __init__(self):\\n super(sppasSymbolSettings, self).__init__()\\n\\n self.__dict__ = dict(\\n unk=\\\"<UNK>\\\",\\n phone=sppasSymbolSettings.__phone_symbols(),\\n ortho=sppasSymbolSettings.__ortho_symbols(),\\n all=sppasSymbolSettings.__all_symbols()\\n )\",\n \"def setHpr(self, hpr):\\n self.cameraNode.setHpr(hpr)\",\n \"def dhcp(self, dhcp):\\n\\n self._dhcp = dhcp\",\n \"def set_wep(self, pardus_profile):\\n\\n self.auth_alg = \\\"open\\\" #TODO: or 'shared' ??\\n self.key_mgmt = \\\"None\\\" # Which stands for WEP based key management\\n self.wep_key0 = str(pardus_profile.get_auth_password()) # Default index\\n self.wep_key_type = \\\"1\\\" # Interpret WEP keys as hex or ascii keys\",\n \"def setHBin(self, hbin):\\n with self.lock:\\n self.hbin = hbin\",\n \"def __init__(self, kippt):\\n self.kippt = kippt\",\n \"def h(self, h):\\n\\n self._h = h\",\n \"def hklin(self, hklin):\\n self._hklin = hklin\",\n \"def set_primary_object_hash(self, hsh):\\n self.hash = hsh\",\n \"def _serverTLS13Handshake(self, settings, clientHello, cipherSuite,\\n privateKey, serverCertChain, version, scheme,\\n srv_alpns, reqCert):\\n prf_name, prf_size = self._getPRFParams(cipherSuite)\\n\\n secret = bytearray(prf_size)\\n\\n share = clientHello.getExtension(ExtensionType.key_share)\\n if share:\\n share_ids = [i.group for i in share.client_shares]\\n for group_name in chain(settings.keyShares, settings.eccCurves,\\n settings.dhGroups):\\n selected_group = getattr(GroupName, group_name)\\n if selected_group in share_ids:\\n cl_key_share = next(i for i in share.client_shares\\n if i.group == selected_group)\\n break\\n else:\\n for result in self._sendError(AlertDescription.internal_error,\\n \\\"HRR did not work?!\\\"):\\n yield result\\n\\n psk = None\\n selected_psk = None\\n resumed_client_cert_chain = None\\n psks = clientHello.getExtension(ExtensionType.pre_shared_key)\\n psk_types = clientHello.getExtension(\\n ExtensionType.psk_key_exchange_modes)\\n if psks and (PskKeyExchangeMode.psk_dhe_ke in psk_types.modes or\\n PskKeyExchangeMode.psk_ke in psk_types.modes) and \\\\\\n (settings.pskConfigs or settings.ticketKeys):\\n for i, ident in enumerate(psks.identities):\\n ticket = None\\n external = True\\n match = [j for j in settings.pskConfigs\\n if j[0] == ident.identity]\\n if not match:\\n (match, ticket) = self._tryDecrypt(settings, ident)\\n external = False\\n if not match:\\n continue\\n match = [match]\\n\\n # check if PSK can be used with selected cipher suite\\n psk_hash = match[0][2] if len(match[0]) > 2 else 'sha256'\\n if psk_hash != prf_name:\\n continue\\n\\n psk = match[0][1]\\n selected_psk = i\\n if ticket:\\n resumed_client_cert_chain = ticket.client_cert_chain\\n try:\\n HandshakeHelpers.verify_binder(\\n clientHello,\\n self._pre_client_hello_handshake_hash,\\n selected_psk,\\n psk,\\n psk_hash,\\n external)\\n except TLSIllegalParameterException as e:\\n for result in self._sendError(\\n AlertDescription.illegal_parameter,\\n str(e)):\\n yield result\\n break\\n\\n sh_extensions = []\\n\\n # we need to gen key share either when we selected psk_dhe_ke or\\n # regular certificate authenticated key exchange (the default)\\n if (psk and\\n PskKeyExchangeMode.psk_dhe_ke in psk_types.modes and\\n \\\"psk_dhe_ke\\\" in settings.psk_modes) or\\\\\\n (psk is None and privateKey):\\n self.ecdhCurve = selected_group\\n kex = self._getKEX(selected_group, version)\\n key_share = self._genKeyShareEntry(selected_group, version)\\n\\n try:\\n shared_sec = kex.calc_shared_key(key_share.private,\\n cl_key_share.key_exchange)\\n except TLSIllegalParameterException as alert:\\n for result in self._sendError(\\n AlertDescription.illegal_parameter,\\n str(alert)):\\n yield result\\n\\n sh_extensions.append(ServerKeyShareExtension().create(key_share))\\n elif (psk is not None and\\n PskKeyExchangeMode.psk_ke in psk_types.modes and\\n \\\"psk_ke\\\" in settings.psk_modes):\\n shared_sec = bytearray(prf_size)\\n else:\\n for result in self._sendError(\\n AlertDescription.handshake_failure,\\n \\\"Could not find acceptable PSK identity nor certificate\\\"):\\n yield result\\n\\n if psk is None:\\n psk = bytearray(prf_size)\\n\\n sh_extensions.append(SrvSupportedVersionsExtension().create(version))\\n if selected_psk is not None:\\n sh_extensions.append(SrvPreSharedKeyExtension()\\n .create(selected_psk))\\n\\n serverHello = ServerHello()\\n # in TLS1.3 the version selected is sent in extension, (3, 3) is\\n # just dummy value to workaround broken middleboxes\\n serverHello.create((3, 3), getRandomBytes(32),\\n clientHello.session_id,\\n cipherSuite, extensions=sh_extensions)\\n\\n msgs = []\\n msgs.append(serverHello)\\n if not self._ccs_sent and clientHello.session_id:\\n ccs = ChangeCipherSpec().create()\\n msgs.append(ccs)\\n for result in self._sendMsgs(msgs):\\n yield result\\n\\n # Early secret\\n secret = secureHMAC(secret, psk, prf_name)\\n\\n # Handshake Secret\\n secret = derive_secret(secret, bytearray(b'derived'), None, prf_name)\\n secret = secureHMAC(secret, shared_sec, prf_name)\\n\\n sr_handshake_traffic_secret = derive_secret(secret,\\n bytearray(b's hs traffic'),\\n self._handshake_hash,\\n prf_name)\\n cl_handshake_traffic_secret = derive_secret(secret,\\n bytearray(b'c hs traffic'),\\n self._handshake_hash,\\n prf_name)\\n self.version = version\\n self._recordLayer.calcTLS1_3PendingState(\\n cipherSuite,\\n cl_handshake_traffic_secret,\\n sr_handshake_traffic_secret,\\n settings.cipherImplementations)\\n\\n self._changeWriteState()\\n\\n ee_extensions = []\\n\\n if clientHello.getExtension(ExtensionType.record_size_limit) and \\\\\\n settings.record_size_limit:\\n ee_extensions.append(RecordSizeLimitExtension().create(\\n min(2**14+1, settings.record_size_limit)))\\n\\n # a bit of a hack to detect if the HRR was sent\\n # as that means that original key share didn't match what we wanted\\n # send the client updated list of shares we support,\\n # preferred ones first\\n if clientHello.getExtension(ExtensionType.cookie):\\n ext = SupportedGroupsExtension()\\n groups = [getattr(GroupName, i) for i in settings.keyShares]\\n groups += [getattr(GroupName, i) for i in settings.eccCurves\\n if getattr(GroupName, i) not in groups]\\n groups += [getattr(GroupName, i) for i in settings.dhGroups\\n if getattr(GroupName, i) not in groups]\\n if groups:\\n ext.create(groups)\\n ee_extensions.append(ext)\\n\\n alpn_ext = clientHello.getExtension(ExtensionType.alpn)\\n if alpn_ext:\\n # error handling was done when receiving ClientHello\\n matched = [i for i in alpn_ext.protocol_names if i in srv_alpns]\\n if matched:\\n ext = ALPNExtension().create([matched[0]])\\n ee_extensions.append(ext)\\n\\n if clientHello.getExtension(ExtensionType.heartbeat):\\n if settings.use_heartbeat_extension:\\n ee_extensions.append(HeartbeatExtension().create(\\n HeartbeatMode.PEER_ALLOWED_TO_SEND))\\n\\n encryptedExtensions = EncryptedExtensions().create(ee_extensions)\\n self._queue_message(encryptedExtensions)\\n\\n if selected_psk is None:\\n\\n # optionally send the client a certificate request\\n if reqCert:\\n\\n # the context SHALL be zero length except in post-handshake\\n ctx = b''\\n\\n # Get list of valid Signing Algorithms\\n # we don't support DSA for client certificates yet\\n cr_settings = settings.validate()\\n cr_settings.dsaSigHashes = []\\n valid_sig_algs = self._sigHashesToList(cr_settings)\\n assert valid_sig_algs\\n\\n certificate_request = CertificateRequest(self.version)\\n certificate_request.create(context=ctx, sig_algs=valid_sig_algs)\\n self._queue_message(certificate_request)\\n\\n certificate = Certificate(CertificateType.x509, self.version)\\n certificate.create(serverCertChain, bytearray())\\n self._queue_message(certificate)\\n\\n certificate_verify = CertificateVerify(self.version)\\n\\n signature_scheme = getattr(SignatureScheme, scheme)\\n\\n signature_context = \\\\\\n KeyExchange.calcVerifyBytes((3, 4), self._handshake_hash,\\n signature_scheme, None, None, None,\\n prf_name, b'server')\\n\\n if signature_scheme in (SignatureScheme.ed25519,\\n SignatureScheme.ed448):\\n hashName = \\\"intrinsic\\\"\\n padType = None\\n saltLen = None\\n sig_func = privateKey.hashAndSign\\n ver_func = privateKey.hashAndVerify\\n elif signature_scheme[1] == SignatureAlgorithm.ecdsa:\\n hashName = HashAlgorithm.toRepr(signature_scheme[0])\\n padType = None\\n saltLen = None\\n sig_func = privateKey.sign\\n ver_func = privateKey.verify\\n else:\\n padType = SignatureScheme.getPadding(scheme)\\n hashName = SignatureScheme.getHash(scheme)\\n saltLen = getattr(hashlib, hashName)().digest_size\\n sig_func = privateKey.sign\\n ver_func = privateKey.verify\\n\\n signature = sig_func(signature_context,\\n padType,\\n hashName,\\n saltLen)\\n if not ver_func(signature, signature_context,\\n padType,\\n hashName,\\n saltLen):\\n for result in self._sendError(\\n AlertDescription.internal_error,\\n \\\"Certificate Verify signature failed\\\"):\\n yield result\\n certificate_verify.create(signature, signature_scheme)\\n\\n self._queue_message(certificate_verify)\\n\\n finished_key = HKDF_expand_label(sr_handshake_traffic_secret,\\n b\\\"finished\\\", b'', prf_size, prf_name)\\n verify_data = secureHMAC(finished_key,\\n self._handshake_hash.digest(prf_name),\\n prf_name)\\n\\n finished = Finished(self.version, prf_size).create(verify_data)\\n\\n self._queue_message(finished)\\n for result in self._queue_flush():\\n yield result\\n\\n self._changeReadState()\\n\\n # Master secret\\n secret = derive_secret(secret, bytearray(b'derived'), None, prf_name)\\n secret = secureHMAC(secret, bytearray(prf_size), prf_name)\\n\\n cl_app_traffic = derive_secret(secret, bytearray(b'c ap traffic'),\\n self._handshake_hash, prf_name)\\n sr_app_traffic = derive_secret(secret, bytearray(b's ap traffic'),\\n self._handshake_hash, prf_name)\\n self._recordLayer.calcTLS1_3PendingState(serverHello.cipher_suite,\\n cl_app_traffic,\\n sr_app_traffic,\\n settings\\n .cipherImplementations)\\n\\n # all the messages sent by the server after the Finished message\\n # MUST be encrypted with ap traffic secret, even if they regard\\n # problems in processing client Certificate, CertificateVerify or\\n # Finished messages\\n self._changeWriteState()\\n\\n client_cert_chain = None\\n #Get [Certificate,] (if was requested)\\n if reqCert and selected_psk is None:\\n for result in self._getMsg(ContentType.handshake,\\n HandshakeType.certificate,\\n CertificateType.x509):\\n if result in (0, 1):\\n yield result\\n else:\\n break\\n client_certificate = result\\n assert isinstance(client_certificate, Certificate)\\n client_cert_chain = client_certificate.cert_chain\\n\\n #Get and check CertificateVerify, if relevant\\n cli_cert_verify_hh = self._handshake_hash.copy()\\n if client_cert_chain and client_cert_chain.getNumCerts():\\n for result in self._getMsg(ContentType.handshake,\\n HandshakeType.certificate_verify):\\n if result in (0, 1):\\n yield result\\n else: break\\n certificate_verify = result\\n assert isinstance(certificate_verify, CertificateVerify)\\n\\n signature_scheme = certificate_verify.signatureAlgorithm\\n\\n valid_sig_algs = self._sigHashesToList(settings,\\n certList=client_cert_chain,\\n version=(3, 4))\\n if signature_scheme not in valid_sig_algs:\\n for result in self._sendError(\\n AlertDescription.illegal_parameter,\\n \\\"Invalid signature on Certificate Verify\\\"):\\n yield result\\n\\n signature_context = \\\\\\n KeyExchange.calcVerifyBytes((3, 4), cli_cert_verify_hh,\\n signature_scheme, None, None, None,\\n prf_name, b'client')\\n\\n public_key = client_cert_chain.getEndEntityPublicKey()\\n\\n if signature_scheme in (SignatureScheme.ed25519,\\n SignatureScheme.ed448):\\n hash_name = \\\"intrinsic\\\"\\n pad_type = None\\n salt_len = None\\n ver_func = public_key.hashAndVerify\\n elif signature_scheme[1] == SignatureAlgorithm.ecdsa:\\n hash_name = HashAlgorithm.toRepr(signature_scheme[0])\\n pad_type = None\\n salt_len = None\\n ver_func = public_key.verify\\n else:\\n scheme = SignatureScheme.toRepr(signature_scheme)\\n pad_type = SignatureScheme.getPadding(scheme)\\n hash_name = SignatureScheme.getHash(scheme)\\n salt_len = getattr(hashlib, hash_name)().digest_size\\n ver_func = public_key.verify\\n\\n if not ver_func(certificate_verify.signature,\\n signature_context,\\n pad_type,\\n hash_name,\\n salt_len):\\n for result in self._sendError(\\n AlertDescription.decrypt_error,\\n \\\"signature verification failed\\\"):\\n yield result\\n\\n # as both exporter and resumption master secrets include handshake\\n # transcript, we need to derive them early\\n exporter_master_secret = derive_secret(secret,\\n bytearray(b'exp master'),\\n self._handshake_hash,\\n prf_name)\\n\\n # verify Finished of client\\n cl_finished_key = HKDF_expand_label(cl_handshake_traffic_secret,\\n b\\\"finished\\\", b'',\\n prf_size, prf_name)\\n cl_verify_data = secureHMAC(cl_finished_key,\\n self._handshake_hash.digest(prf_name),\\n prf_name)\\n for result in self._getMsg(ContentType.handshake,\\n HandshakeType.finished,\\n prf_size):\\n if result in (0, 1):\\n yield result\\n else:\\n break\\n cl_finished = result\\n assert isinstance(cl_finished, Finished)\\n if cl_finished.verify_data != cl_verify_data:\\n for result in self._sendError(\\n AlertDescription.decrypt_error,\\n \\\"Finished value is not valid\\\"):\\n yield result\\n\\n # disallow CCS messages after handshake\\n self._middlebox_compat_mode = False\\n\\n resumption_master_secret = derive_secret(secret,\\n bytearray(b'res master'),\\n self._handshake_hash,\\n prf_name)\\n\\n self._first_handshake_hashes = self._handshake_hash.copy()\\n\\n self.session = Session()\\n self.extendedMasterSecret = True\\n server_name = None\\n if clientHello.server_name:\\n server_name = clientHello.server_name.decode('utf-8')\\n\\n app_proto = None\\n alpnExt = encryptedExtensions.getExtension(ExtensionType.alpn)\\n if alpnExt:\\n app_proto = alpnExt.protocol_names[0]\\n\\n if not client_cert_chain and resumed_client_cert_chain:\\n client_cert_chain = resumed_client_cert_chain\\n\\n self.session.create(secret,\\n bytearray(b''), # no session_id\\n serverHello.cipher_suite,\\n bytearray(b''), # no SRP\\n client_cert_chain,\\n serverCertChain,\\n None,\\n False,\\n server_name,\\n encryptThenMAC=False,\\n extendedMasterSecret=True,\\n appProto=app_proto,\\n cl_app_secret=cl_app_traffic,\\n sr_app_secret=sr_app_traffic,\\n exporterMasterSecret=exporter_master_secret,\\n resumptionMasterSecret=resumption_master_secret,\\n # NOTE it must be a reference, not a copy\\n tickets=self.tickets)\\n\\n # switch to application_traffic_secret for client packets\\n self._changeReadState()\\n\\n for result in self._serverSendTickets(settings):\\n yield result\\n\\n yield \\\"finished\\\"\",\n \"def vscp_pythia_configure(self):\\n vscp_pythia_configure = self._lib.vscp_pythia_configure\\n vscp_pythia_configure.argtypes = []\\n vscp_pythia_configure.restype = c_int\\n return vscp_pythia_configure()\",\n \"def set_pubkey(self, pkey):\\n return m2.x509_req_set_pubkey(self.req, pkey.pkey)\",\n \"def _init_key_settings(self):\\n self.minKeySize = 1023\\n self.maxKeySize = 8193\\n self.rsaSigHashes = list(RSA_SIGNATURE_HASHES)\\n self.rsaSchemes = list(RSA_SCHEMES)\\n self.dsaSigHashes = list(DSA_SIGNATURE_HASHES)\\n self.virtual_hosts = []\\n # DH key settings\\n self.eccCurves = list(CURVE_NAMES)\\n self.dhParams = None\\n self.dhGroups = list(ALL_DH_GROUP_NAMES)\\n self.defaultCurve = \\\"secp256r1\\\"\\n self.keyShares = [\\\"secp256r1\\\", \\\"x25519\\\"]\\n self.padding_cb = None\\n self.use_heartbeat_extension = True\\n self.heartbeat_response_callback = None\",\n \"def test_set_public_key_setter(self) -> None:\\n\\n expected = self.pem_public_key.decode()\\n\\n encryptor = DataEncryption()\\n encryptor.set_public_key(self.pem_public_key)\\n\\n # pylint: disable=protected-access\\n actual = encryptor._loaded_public_key.public_bytes(\\n serialization.Encoding.PEM, serialization.PublicFormat.PKCS1\\n ).decode()\\n\\n self.assertEqual(expected, actual)\",\n \"def Host(self, h):\\r\\n\\r\\n self.host = h\\r\\n return self\",\n \"def SetPreference(self, preferenceKey, value):\\r\\n\\r\\n config = self.GetConfig()\\r\\n config.Write(preferenceKey, str(value))\\r\\n config.Flush()\",\n \"def set_phs(self):\\n return 'phs{:06}'.format(self.i_accession)\",\n \"def __init__(self):\\n super(sppasSeparatorSettings, self).__init__()\\n self.__dict__ = dict(\\n phonemes=\\\"-\\\", # X-SAMPA standard\\n syllables=\\\".\\\", # X-SAMPA standard\\n variants=\\\"|\\\" # used for all alternative tags\\n )\",\n \"def setup_keys(self, dh_object, public_key, private_key):\\n public_numbers = DHPublicNumbers(public_key, dh_object.parameter_numbers)\\n private_numbers = DHPrivateNumbers(private_key, public_numbers)\\n dh_object.private_key = private_numbers.private_key(default_backend())\",\n \"def setTopP(self, value):\\n return self._set(topP=value)\",\n \"def setTopP(self, value):\\n return self._set(topP=value)\",\n \"def setTopP(self, value):\\n return self._set(topP=value)\",\n \"def p2pkh(btcAddress):\\n ret = CScript([OP_DUP, OP_HASH160, bitcoinAddress2bin(btcAddress), OP_EQUALVERIFY, OP_CHECKSIG])\\n return ret\",\n \"def set_hp_properties(self, name, hp_type=None, scale=None):\\n hp_list = [hp for hp in self.hyper_params if hp.name == name]\\n assert len(hp_list) == 1\\n hp = hp_list[0]\\n assert isinstance(hp, HyperParameter)\\n if hp.hp_type is None: hp.hp_type = hp_type\\n if hp.scale is None: hp.scale = scale\",\n \"def plogi_settings(self, plogi_settings):\\n\\n self._plogi_settings = plogi_settings\",\n \"def psid(self, psid):\\n\\n self._psid = psid\",\n \"def set_pno(self, pno):\\n self.__pno = pno\",\n \"def preference(self, preference):\\n\\n self._preference = preference\",\n \"def setPassphrase( self , passphrase ):\\n\\t\\tself.passphrase\\t= passphrase\\n\\t\\t\\n\\t\\t# Generate and log the generated PMK.\\n\\t\\tself.PMK = pbkdf2_bin( self.passphrase , self.ssid , 4096 , 32 )\\n\\t\\tself.logger.logKey( 'Pairwise Master Key' , self.PMK )\",\n \"def set_haiku(self, haiku):\\n self.haiku = haiku\",\n \"def svn_client_ctx_t_config_set(svn_client_ctx_t_self, apr_hash_t_config): # real signature unknown; restored from __doc__\\n pass\",\n \"def set_hsdsch_mpo(self, carrier, control=\\\"AUTO\\\", pwrOffsetManual=\\\"\\\"):\\r\\r\\n self.write('CONFigure:WCDMa:SIGN:DL:CARRier%s:ENHanced:HSPDsch:POFFset %s'\\r\\r\\n %(carrier, control))\",\n \"def set_configure_with_dhcp(self, bConfigureWithDhcp):\\n\\t\\tcall_sdk_function('PrlVmDevNet_SetConfigureWithDhcp', self.handle, bConfigureWithDhcp)\",\n \"def set_counter_based_otp(self, otp_passcode: str):\\n self._hotp = HOTP(otp_passcode)\",\n \"def set_hbond(self) -> None:\\n ...\",\n \"def hypertension(self, hypertension):\\n\\n self.logger.debug(\\\"In 'hypertension' setter.\\\")\\n\\n self._hypertension = hypertension\",\n \"def set_haproxy(self):\\n logging.info('currently only haproxy is supported for load balancing')\\n self.inventory_dict['csah']['vars']['proxy'] = 'haproxy'\\n self.inventory_dict['csah']['vars']['haproxy_conf'] = '/etc/haproxy/haproxy.cfg'\\n self.inventory_dict['csah']['vars']['master_ports'] = [{'port': 6443, 'description': 'apiserver'},\\n {'port': 22623 , 'description': 'configserver'}]\\n self.inventory_dict['csah']['vars']['worker_ports'] = [{'port': 80, 'description': 'http'},\\n {'port': 443, 'description': 'https'}]\",\n \"def host_option(self, host_option):\\n allowed_values = [\\\"admin_only\\\", \\\"player\\\", \\\"non_player\\\"]\\n if host_option not in allowed_values:\\n raise ValueError(\\n \\\"Invalid value for `host_option` ({0}), must be one of {1}\\\"\\n .format(host_option, allowed_values)\\n )\\n\\n self._host_option = host_option\",\n \"def __init__(self):\\n super(sppasPathSettings, self).__init__()\\n\\n sppas_dir = os.path.dirname(os.path.dirname(\\n os.path.dirname(os.path.abspath(__file__))))\\n\\n self.__dict__ = dict(\\n sppas=sppas_dir,\\n cli=os.path.join(sppas_dir, \\\"bin\\\"),\\n etc=os.path.join(sppas_dir, \\\"etc\\\"),\\n po=os.path.join(sppas_dir, \\\"po\\\"),\\n src=os.path.join(sppas_dir, \\\"src\\\"),\\n plugins=os.path.join(os.path.dirname(sppas_dir), \\\"plugins\\\"),\\n resources=os.path.join(os.path.dirname(sppas_dir), \\\"resources\\\"),\\n samples=os.path.join(os.path.dirname(sppas_dir), \\\"samples\\\"),\\n logs=os.path.join(os.path.dirname(sppas_dir), \\\".logs\\\"),\\n wkps=os.path.join(os.path.dirname(sppas_dir), \\\"workspaces\\\"),\\n trash=os.path.join(os.path.dirname(sppas_dir), \\\".trash\\\"),\\n )\",\n \"def setPreferences(self, key, value):\\n Preferences.Prefs.settings.setValue(\\n self.PreferencesKey + \\\"/\\\" + key, value)\\n \\n if key in [\\\"VirtualEnvironmentPy2\\\", \\\"VirtualEnvironmentPy3\\\"]:\\n self.__reregisterProjectType()\\n elif key == \\\"TranslationsEditor\\\":\\n if self.__object:\\n self.__object.registerOpenHook()\",\n \"def _AddPerInstanceSshkey(self):\\n if self._ssh_public_key_path:\\n rsa = self._LoadSshPublicKey(self._ssh_public_key_path)\\n logger.info(\\\"ssh_public_key_path is specified in config: %s, \\\"\\n \\\"will add the key to the instance.\\\",\\n self._ssh_public_key_path)\\n self._metadata[\\\"sshKeys\\\"] = \\\"{0}:{2}\\\\n{1}:{2}\\\".format(getpass.getuser(),\\n constants.GCE_USER,\\n rsa)\\n else:\\n logger.warning(\\n \\\"ssh_public_key_path is not specified in config, \\\"\\n \\\"only project-wide key will be effective.\\\")\",\n \"def configure_stp_instance(self, instance, **kwargs):\\n pass\",\n \"def load_keypass_options(subcmd, pfx):\\n\\n keypass_grp = subcmd.add_argument_group('Key / Password Select')\\n\\n kpg = keypass_grp.add_mutually_exclusive_group(required=True)\\n\\n kpg.add_argument(\\n '--use-key', action='store_true', dest='use_key',\\n help='enables usage of key for {}cryption - enter key in secure prompt or specify file with -i'.format(pfx))\\n\\n kpg.add_argument(\\n '--use-pw', action='store_true', dest='use_pw',\\n help='enables usage of password, salt, iterations for {}cryption - enter pw in secure prompt or specify file with -i'.format(pfx))\\n\\n load_pw_options(subcmd)\",\n \"def preference(self, key, value):\\n self.command(\\\"preference %(key)s %(value)s\\\" % locals())\",\n \"def dhcp_options_id(self, dhcp_options_id):\\n self._dhcp_options_id = dhcp_options_id\",\n \"def setPIDSourceType(self, pidSource: PIDSourceType) -> None:\\n self.pidSource = ...\",\n \"def set_totp(self, totp_secret):\\n self.totp = TOTP(totp_secret)\\n return self\",\n \"def _wrap_publickey(self) -> None:\\n p_der = ffi.new(\\\"unsigned char **\\\")\\n der_len = lib.i2d_PublicKey(self._pkey, p_der)\\n if der_len < 0:\\n raise InvalidPKeyError(\\\"Could not serialize public key\\\")\\n try:\\n der = ffi.buffer(p_der[0], der_len)[:]\\n try:\\n self._key = load_der_public_key(der, backend=default_backend())\\n except ValueError as exc:\\n raise InvalidPKeyError from exc\\n finally:\\n lib.OPENSSL_free(p_der[0])\",\n \"def privacy_protocol(self, privacy_protocol):\\n\\n self._privacy_protocol = privacy_protocol\",\n \"def setKey(self, *args):\\n return _libsbml.ConversionOption_setKey(self, *args)\",\n \"def SetOutput(self, output: 'itkPointSetSS2') -> \\\"void\\\":\\n return _itkMeshSourcePython.itkMeshSourcePSSS2_SetOutput(self, output)\",\n \"def pkey(self) -> ffi.CType:\\n return self._pkey\",\n \"def setCryptographicHandlers( self , tkip = None , aes = None ):\\n\\t\\tself.handleTKIP = tkip\\n\\t\\tself.handleAES \\t= aes\",\n \"def setSignPDF(self, keystoreURL, keyAlias, keystorePassword, keystoreType, signingMode):\\n self.PDFreactorConfiguration.in1[\\\"signPdfKeystoreURL\\\"] = keystoreURL\\n self.PDFreactorConfiguration.in1[\\\"signPdfKeyAlias\\\"] = keyAlias\\n self.PDFreactorConfiguration.in1[\\\"signPdfKeystorePassword\\\"] = keystorePassword\\n self.PDFreactorConfiguration.in1[\\\"signPdfKeystoreType\\\"] = keystoreType\\n self.PDFreactorConfiguration.in1[\\\"signPdfSigningMode\\\"] = signingMode\",\n \"def load_key(self, pemfile_path_abs: str, set_priv=False) -> None:\\n return None\",\n \"def hyperlipidemia(self, hyperlipidemia):\\n\\n self.logger.debug(\\\"In 'hyperlipidemia' setter.\\\")\\n\\n self._hyperlipidemia = hyperlipidemia\",\n \"def load_xonsh_bindings(ptk_bindings: KeyBindingsBase) -> KeyBindingsBase:\\n key_bindings = KeyBindings()\\n handle = key_bindings.add\\n has_selection = HasSelection()\\n insert_mode = ViInsertMode() | EmacsInsertMode()\\n\\n if XSH.env[\\\"XONSH_CTRL_BKSP_DELETION\\\"]:\\n # Not all terminal emulators emit the same keys for backspace, therefore\\n # ptk always maps backspace (\\\"\\\\x7f\\\") to ^H (\\\"\\\\x08\\\"), and all the backspace bindings are registered for ^H.\\n # This means we can't re-map backspace and instead we register a new \\\"real-ctrl-bksp\\\" key.\\n # See https://github.com/xonsh/xonsh/issues/4407\\n\\n if ON_WINDOWS:\\n # On windows BKSP is \\\"\\\\x08\\\" and CTRL-BKSP is \\\"\\\\x7f\\\"\\n REAL_CTRL_BKSP = \\\"\\\\x7f\\\"\\n\\n # PTK uses a second mapping\\n from prompt_toolkit.input import win32 as ptk_win32\\n\\n ptk_win32.ConsoleInputReader.mappings[b\\\"\\\\x7f\\\"] = REAL_CTRL_BKSP # type: ignore\\n else:\\n REAL_CTRL_BKSP = \\\"\\\\x08\\\"\\n\\n # Prompt-toolkit allows using single-character keys that aren't in the `Keys` enum.\\n ansi_escape_sequences.ANSI_SEQUENCES[REAL_CTRL_BKSP] = REAL_CTRL_BKSP # type: ignore\\n ansi_escape_sequences.REVERSE_ANSI_SEQUENCES[REAL_CTRL_BKSP] = REAL_CTRL_BKSP # type: ignore\\n\\n @handle(REAL_CTRL_BKSP, filter=insert_mode)\\n def delete_word(event):\\n \\\"\\\"\\\"Delete a single word (like ALT-backspace)\\\"\\\"\\\"\\n get_by_name(\\\"backward-kill-word\\\").call(event)\\n\\n @handle(Keys.Tab, filter=tab_insert_indent)\\n def insert_indent(event):\\n \\\"\\\"\\\"\\n If there are only whitespaces before current cursor position insert\\n indent instead of autocompleting.\\n \\\"\\\"\\\"\\n env = XSH.env\\n event.cli.current_buffer.insert_text(env.get(\\\"INDENT\\\"))\\n\\n @handle(Keys.Tab, filter=~tab_insert_indent & tab_menu_complete)\\n def menu_complete_select(event):\\n \\\"\\\"\\\"Start completion in menu-complete mode, or tab to next completion\\\"\\\"\\\"\\n b = event.current_buffer\\n if b.complete_state:\\n b.complete_next()\\n else:\\n b.start_completion(select_first=True)\\n\\n @handle(Keys.ControlX, Keys.ControlE, filter=~has_selection)\\n def open_editor(event):\\n \\\"\\\"\\\"Open current buffer in editor\\\"\\\"\\\"\\n event.current_buffer.open_in_editor(event.cli)\\n\\n @handle(Keys.BackTab, filter=insert_mode)\\n def insert_literal_tab(event):\\n \\\"\\\"\\\"Insert literal tab on Shift+Tab instead of autocompleting\\\"\\\"\\\"\\n b = event.current_buffer\\n if b.complete_state:\\n b.complete_previous()\\n else:\\n env = XSH.env\\n event.cli.current_buffer.insert_text(env.get(\\\"INDENT\\\"))\\n\\n def generate_parens_handlers(left, right):\\n @handle(left, filter=autopair_condition)\\n def insert_left_paren(event):\\n buffer = event.cli.current_buffer\\n\\n if has_selection():\\n wrap_selection(buffer, left, right)\\n elif whitespace_or_bracket_after():\\n buffer.insert_text(left)\\n buffer.insert_text(right, move_cursor=False)\\n else:\\n buffer.insert_text(left)\\n\\n @handle(right, filter=autopair_condition)\\n def overwrite_right_paren(event):\\n buffer = event.cli.current_buffer\\n\\n if buffer.document.current_char == right:\\n buffer.cursor_position += 1\\n else:\\n buffer.insert_text(right)\\n\\n generate_parens_handlers(\\\"(\\\", \\\")\\\")\\n generate_parens_handlers(\\\"[\\\", \\\"]\\\")\\n generate_parens_handlers(\\\"{\\\", \\\"}\\\")\\n\\n def generate_quote_handler(quote):\\n @handle(quote, filter=autopair_condition)\\n def insert_quote(event):\\n buffer = event.cli.current_buffer\\n\\n if has_selection():\\n wrap_selection(buffer, quote, quote)\\n elif buffer.document.current_char == quote:\\n buffer.cursor_position += 1\\n elif whitespace_or_bracket_before() and whitespace_or_bracket_after():\\n buffer.insert_text(quote)\\n buffer.insert_text(quote, move_cursor=False)\\n else:\\n buffer.insert_text(quote)\\n\\n generate_quote_handler(\\\"'\\\")\\n generate_quote_handler('\\\"')\\n\\n @handle(Keys.Backspace, filter=autopair_condition)\\n def delete_brackets_or_quotes(event):\\n \\\"\\\"\\\"Delete empty pair of brackets or quotes\\\"\\\"\\\"\\n buffer = event.cli.current_buffer\\n before = buffer.document.char_before_cursor\\n after = buffer.document.current_char\\n\\n if any(\\n [before == b and after == a for (b, a) in [\\\"()\\\", \\\"[]\\\", \\\"{}\\\", \\\"''\\\", '\\\"\\\"']]\\n ):\\n buffer.delete(1)\\n\\n buffer.delete_before_cursor(1)\\n\\n @handle(Keys.ControlD, filter=ctrl_d_condition)\\n def call_exit_alias(event):\\n \\\"\\\"\\\"Use xonsh exit function\\\"\\\"\\\"\\n b = event.cli.current_buffer\\n b.validate_and_handle()\\n xonsh_exit([])\\n\\n @handle(Keys.ControlJ, filter=IsMultiline() & insert_mode)\\n @handle(Keys.ControlM, filter=IsMultiline() & insert_mode)\\n def multiline_carriage_return(event):\\n \\\"\\\"\\\"Wrapper around carriage_return multiline parser\\\"\\\"\\\"\\n b = event.cli.current_buffer\\n carriage_return(b, event.cli)\\n\\n @handle(Keys.ControlJ, filter=should_confirm_completion)\\n @handle(Keys.ControlM, filter=should_confirm_completion)\\n def enter_confirm_completion(event):\\n \\\"\\\"\\\"Ignore <enter> (confirm completion)\\\"\\\"\\\"\\n event.current_buffer.complete_state = None\\n\\n @handle(Keys.Escape, filter=should_confirm_completion)\\n def esc_cancel_completion(event):\\n \\\"\\\"\\\"Use <ESC> to cancel completion\\\"\\\"\\\"\\n event.cli.current_buffer.cancel_completion()\\n\\n @handle(Keys.Escape, Keys.ControlJ)\\n def execute_block_now(event):\\n \\\"\\\"\\\"Execute a block of text irrespective of cursor position\\\"\\\"\\\"\\n b = event.cli.current_buffer\\n b.validate_and_handle()\\n\\n @handle(Keys.Left, filter=beginning_of_line)\\n def wrap_cursor_back(event):\\n \\\"\\\"\\\"Move cursor to end of previous line unless at beginning of\\n document\\n \\\"\\\"\\\"\\n b = event.cli.current_buffer\\n b.cursor_up(count=1)\\n relative_end_index = b.document.get_end_of_line_position()\\n b.cursor_right(count=relative_end_index)\\n\\n @handle(Keys.Right, filter=end_of_line)\\n def wrap_cursor_forward(event):\\n \\\"\\\"\\\"Move cursor to beginning of next line unless at end of document\\\"\\\"\\\"\\n b = event.cli.current_buffer\\n relative_begin_index = b.document.get_start_of_line_position()\\n b.cursor_left(count=abs(relative_begin_index))\\n b.cursor_down(count=1)\\n\\n @handle(Keys.ControlM, filter=IsSearching())\\n @handle(Keys.ControlJ, filter=IsSearching())\\n def accept_search(event):\\n search.accept_search()\\n\\n @handle(Keys.ControlZ)\\n def skip_control_z(event):\\n \\\"\\\"\\\"Prevents the writing of ^Z to the prompt, if Ctrl+Z was pressed\\n during the previous command.\\n \\\"\\\"\\\"\\n pass\\n\\n @handle(Keys.ControlX, Keys.ControlX, filter=has_selection)\\n def _cut(event):\\n \\\"\\\"\\\"Cut selected text.\\\"\\\"\\\"\\n data = event.current_buffer.cut_selection()\\n event.app.clipboard.set_data(data)\\n\\n @handle(Keys.ControlX, Keys.ControlC, filter=has_selection)\\n def _copy(event):\\n \\\"\\\"\\\"Copy selected text.\\\"\\\"\\\"\\n data = event.current_buffer.copy_selection()\\n event.app.clipboard.set_data(data)\\n\\n @handle(Keys.ControlV, filter=insert_mode | has_selection)\\n def _yank(event):\\n \\\"\\\"\\\"Paste selected text.\\\"\\\"\\\"\\n buff = event.current_buffer\\n if buff.selection_state:\\n buff.cut_selection()\\n get_by_name(\\\"yank\\\").call(event)\\n\\n def create_alias(new_keys, original_keys):\\n bindings = ptk_bindings.get_bindings_for_keys(tuple(original_keys))\\n for original_binding in bindings:\\n handle(*new_keys, filter=original_binding.filter)(original_binding.handler)\\n\\n # Complete a single auto-suggestion word\\n create_alias([Keys.ControlRight], [\\\"escape\\\", \\\"f\\\"])\\n\\n # since macOS uses Control as reserved, then we use the alt/option key instead\\n # which is mapped as the \\\"escape\\\" key\\n create_alias([\\\"escape\\\", \\\"right\\\"], [\\\"escape\\\", \\\"f\\\"])\\n\\n return key_bindings\",\n \"def set_field(self,Hext):\\n self.raw_parameters[\\\"Hext\\\"] = Hext\\n self.parameters = NormalizedParameters(self.raw_parameters)\\n self._load()\",\n \"def addPHTitration(default_pH_titration=(0,16,0.25)):\\n \\n parser.add_option(\\\"-P\\\",\\\"--pH-titration\\\",action=\\\"store\\\",type=\\\"float\\\",\\n dest=\\\"pHtitr\\\",nargs=3,\\n help=\\\"pH titration for UHBD calculations. PHTITR is a \\\\\\n set of three values PH_START PH_STOP PH_INTERVAL. \\\\\\n (Default 0 16 0.25)\\\",\\n default=default_pH_titration)\",\n \"def is_pkh(v) -> bool:\\n try:\\n validate_pkh(v)\\n except (ValueError, TypeError):\\n return False\\n return True\",\n \"def hive_options(self, hive_options):\\n self._hive_options = hive_options\",\n \"def _set_hop_id(self, v, load=False):\\n parent = getattr(self, \\\"_parent\\\", None)\\n if parent is not None and load is False:\\n raise AttributeError(\\\"Cannot set keys directly when\\\" +\\n \\\" within an instantiated list\\\")\\n\\n try:\\n t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name=\\\"hop-id\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True)\\n except (TypeError, ValueError):\\n raise ValueError(\\\"\\\"\\\"hop_id must be of a type compatible with base=unicode, is_leaf=True, yang_name=\\\"hop-id\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True\\\"\\\"\\\")\\n self.__hop_id = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def response_host(self, response_host):\\n\\n self._response_host = response_host\",\n \"def response_host(self, response_host):\\n\\n self._response_host = response_host\",\n \"def host_ip(self, host_ip):\\n\\n self._host_ip = host_ip\",\n \"def writeto(self,output_file,**kwargs):\\n dump_pkl(self._properties,output_file,**kwargs)\\n return\",\n \"def __init__(__self__, *,\\n gcp_kms_encryption_key: Optional[pulumi.Input[str]] = None):\\n if gcp_kms_encryption_key is not None:\\n pulumi.set(__self__, \\\"gcp_kms_encryption_key\\\", gcp_kms_encryption_key)\",\n \"def set_pid(self, kp=None, ki=None, kd=None):\\n if kp is not None:\\n self.k_p = kp\\n if ki is not None:\\n self.k_i = ki\\n if kd is not None:\\n self.k_d = kd\\n\\n self.reset_sum()\",\n \"def __init__(self, printer):\\n super(PowershellParentEnvironment, self).__init__()\\n self._printer = printer\",\n \"def __init__(__self__, *,\\n id: pulumi.Input[str],\\n public_signing_key: pulumi.Input[str],\\n signing_certificate_thumbprint: Optional[pulumi.Input[str]] = None):\\n pulumi.set(__self__, \\\"id\\\", id)\\n pulumi.set(__self__, \\\"public_signing_key\\\", public_signing_key)\\n if signing_certificate_thumbprint is not None:\\n pulumi.set(__self__, \\\"signing_certificate_thumbprint\\\", signing_certificate_thumbprint)\",\n \"def _set_propreties(self):\\n pass\",\n \"def post_process(self, packet: 'dict[str, Any]') -> 'SMFIdentificationBasedDPDOption':\\n ret = super().post_process(packet) # type: SMFIdentificationBasedDPDOption\\n ret.mode = Enum_SMFDPDMode.H_DPD\\n return ret\",\n \"def set_ip(self, ip: str, host_addr: str) -> None:\\n self.config[\\\"linkIp\\\"] = ip\\n self.config[\\\"ngapIp\\\"] = ip\\n self.config[\\\"gtpIp\\\"] = ip\",\n \"def set_options(self, kvlist):\\r\\n if not kvlist:\\r\\n return\\r\\n msg = \\\" \\\".join([\\\"%s=\\\\\\\"%s\\\\\\\"\\\"%(k,quote(v)) for k,v in kvlist])\\r\\n return self.sendAndRecv(\\\"SETCONF %s\\\\r\\\\n\\\"%msg)\",\n \"def set_extensions_to_default(self):\\n if self.cert_type is SSHCertificateType.USER:\\n self.extensions = {'permit-X11-forwarding',\\n 'permit-agent-forwarding',\\n 'permit-port-forwarding',\\n 'permit-pty', 'permit-user-rc'}\\n else:\\n # SSHCertificateType.HOST has no applicable extensions.\\n self.clear_extensions()\",\n \"def __init__(__self__, *,\\n public_keys: Optional[pulumi.Input[Sequence[pulumi.Input['LinuxProfilePropertiesPublicKeysArgs']]]] = None):\\n if public_keys is not None:\\n pulumi.set(__self__, \\\"public_keys\\\", public_keys)\",\n \"def public_key(self, public_key):\\n self._public_key = public_key\\n return self\",\n \"def pvd(self, pvd):\\n\\n self.logger.debug(\\\"In 'pvd' setter.\\\")\\n\\n self._pvd = pvd\",\n \"def setUp(self):\\n\\n self.private_key = self.get_new_key()\\n self.public_key = self.private_key.public_key()\\n\\n self.pem_private_key = self.private_key.private_bytes(\\n serialization.Encoding.PEM,\\n serialization.PrivateFormat.PKCS8,\\n serialization.NoEncryption(),\\n )\\n self.encrypted_pem_private_key = self.private_key.private_bytes(\\n serialization.Encoding.PEM,\\n serialization.PrivateFormat.PKCS8,\\n serialization.BestAvailableEncryption(self.private_key_password),\\n )\\n\\n self.pem_public_key = self.public_key.public_bytes(\\n serialization.Encoding.PEM, serialization.PublicFormat.PKCS1\\n )\",\n \"def set_config(self, hVmCfg):\\n\\t\\tcall_sdk_function('PrlVm_SetConfig', self.handle, conv_handle_arg(hVmCfg))\",\n \"def h_27(options,buildout):\\n h(options, buildout, '27', options['configure-options'])\",\n \"def work_hours_setting(self, work_hours_setting):\\n\\n self._work_hours_setting = work_hours_setting\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.56403214","0.5224331","0.5040199","0.50149983","0.48443633","0.48201424","0.48000458","0.4754778","0.47419602","0.4728604","0.46491504","0.45619443","0.45580828","0.45580828","0.45580828","0.4547807","0.4547807","0.4547807","0.4473194","0.4460671","0.44483814","0.44179884","0.44020486","0.4400223","0.4393183","0.4372079","0.43650445","0.43517464","0.43492627","0.43449652","0.43285197","0.43194243","0.43120864","0.4309677","0.4282892","0.42613274","0.4254538","0.4234433","0.4234433","0.4234433","0.41997427","0.41887072","0.41861418","0.41828713","0.4180834","0.41716826","0.41667092","0.41577423","0.4145595","0.41384017","0.41369027","0.41245115","0.41142958","0.4112493","0.41033795","0.40973917","0.40809843","0.40699825","0.40649515","0.40571067","0.4054637","0.40532914","0.4044104","0.40428624","0.40395054","0.40392593","0.40346354","0.40315342","0.40301147","0.40246308","0.4023935","0.40193754","0.4016958","0.401351","0.40128827","0.4004864","0.40029886","0.399636","0.3993855","0.39885333","0.39881104","0.39881104","0.39880273","0.39854556","0.39824364","0.3978516","0.39756408","0.39693558","0.39588842","0.39578918","0.3954433","0.39509735","0.3947725","0.39453262","0.3942361","0.39328927","0.39325115","0.39264816","0.39250198","0.39191577"],"string":"[\n \"0.56403214\",\n \"0.5224331\",\n \"0.5040199\",\n \"0.50149983\",\n \"0.48443633\",\n \"0.48201424\",\n \"0.48000458\",\n \"0.4754778\",\n \"0.47419602\",\n \"0.4728604\",\n \"0.46491504\",\n \"0.45619443\",\n \"0.45580828\",\n \"0.45580828\",\n \"0.45580828\",\n \"0.4547807\",\n \"0.4547807\",\n \"0.4547807\",\n \"0.4473194\",\n \"0.4460671\",\n \"0.44483814\",\n \"0.44179884\",\n \"0.44020486\",\n \"0.4400223\",\n \"0.4393183\",\n \"0.4372079\",\n \"0.43650445\",\n \"0.43517464\",\n \"0.43492627\",\n \"0.43449652\",\n \"0.43285197\",\n \"0.43194243\",\n \"0.43120864\",\n \"0.4309677\",\n \"0.4282892\",\n \"0.42613274\",\n \"0.4254538\",\n \"0.4234433\",\n \"0.4234433\",\n \"0.4234433\",\n \"0.41997427\",\n \"0.41887072\",\n \"0.41861418\",\n \"0.41828713\",\n \"0.4180834\",\n \"0.41716826\",\n \"0.41667092\",\n \"0.41577423\",\n \"0.4145595\",\n \"0.41384017\",\n \"0.41369027\",\n \"0.41245115\",\n \"0.41142958\",\n \"0.4112493\",\n \"0.41033795\",\n \"0.40973917\",\n \"0.40809843\",\n \"0.40699825\",\n \"0.40649515\",\n \"0.40571067\",\n \"0.4054637\",\n \"0.40532914\",\n \"0.4044104\",\n \"0.40428624\",\n \"0.40395054\",\n \"0.40392593\",\n \"0.40346354\",\n \"0.40315342\",\n \"0.40301147\",\n \"0.40246308\",\n \"0.4023935\",\n \"0.40193754\",\n \"0.4016958\",\n \"0.401351\",\n \"0.40128827\",\n \"0.4004864\",\n \"0.40029886\",\n \"0.399636\",\n \"0.3993855\",\n \"0.39885333\",\n \"0.39881104\",\n \"0.39881104\",\n \"0.39880273\",\n \"0.39854556\",\n \"0.39824364\",\n \"0.3978516\",\n \"0.39756408\",\n \"0.39693558\",\n \"0.39588842\",\n \"0.39578918\",\n \"0.3954433\",\n \"0.39509735\",\n \"0.3947725\",\n \"0.39453262\",\n \"0.3942361\",\n \"0.39328927\",\n \"0.39325115\",\n \"0.39264816\",\n \"0.39250198\",\n \"0.39191577\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7709247"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":24576,"cells":{"query":{"kind":"string","value":"Returns the model properties as a dict"},"document":{"kind":"string","value":"def to_dict(self, serialize=False):\n result = {}\n\n def convert(x):\n if hasattr(x, \"to_dict\"):\n args = getfullargspec(x.to_dict).args\n if len(args) == 1:\n return x.to_dict()\n else:\n return x.to_dict(serialize)\n else:\n return x\n\n for attr, _ in six.iteritems(self.openapi_types):\n value = getattr(self, attr)\n attr = self.attribute_map.get(attr, attr) if serialize else attr\n if isinstance(value, list):\n result[attr] = list(map(\n lambda x: convert(x),\n value\n ))\n elif isinstance(value, dict):\n result[attr] = dict(map(\n lambda item: (item[0], convert(item[1])),\n value.items()\n ))\n else:\n result[attr] = convert(value)\n\n return result"},"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 to_dict(self):\n return self.properties","def to_dict(self):\n return self.properties","def get_properties(self):\n return self.properties","def asdict(self):\n return self._prop_dict","def json(self):\n rv = {\n prop: getattr(self, prop)\n for prop in self.__properties__\n if prop in vars(self)\n }\n rv.update(self._props)\n return rv","def get_properties(self):\n return self.properties","def get_properties():","def getProperties():","def properties(self):\r\n if self._properties is None:\r\n res = self._con.get(self._url, {'f':'json'})\r\n self._properties = PropertyMap(res)\r\n return self._properties","def properties(self):\r\n if self._properties is None:\r\n res = self._con.get(self._url, {'f':'json'})\r\n self._properties = PropertyMap(res)\r\n return self._properties","def getProperties(self):\n return self.properties","def __properties__(self) -> dict:\r\n parameters = [\r\n d for d in dir(self) if (d[0] != \"_\") and (d.count(\"set\") == 0)\r\n and (d.count(\"_c\") == 0) and (d.count(\"_f\") == 0)\r\n ]\r\n\r\n return self.__as_json__(parameters)","def json_properties(self):\n attributes = []\n all = vars(self)\n for var in all:\n if var[:1] != '_':\n attributes.append(var)\n if isinstance(self, db.Model):\n properties = self.properties().keys()\n for property in properties:\n if property[:1] != '_':\n attributes.append(property)\n return attributes","def properties(self) -> Any:\n return pulumi.get(self, \"properties\")","def _properties(self) -> dict[str, dict[str, str]]:\n schema = self.schema(by_alias=False)\n if schema.get('properties') is not None:\n return schema.get('properties', {})\n return schema.get('definitions', {}).get(self.__class__.__name__, {}).get('properties', {})","def get_model_properties(self):\n properties = {}\n\n filename = self._get_data_filename(\"modelargs.json\")\n with open(filename, \"r\") as f:\n results = json.loads(f.read())\n properties[\"image_size\"] = results.get(\"image_size\")\n properties[\"num_classes\"] = results.get(\"num_classes\")\n properties[\"model\"] = results.get(\"model\")\n properties[\"name\"] = results.get(\"name\")\n properties[\"filter_size\"] = results.get(\"filter_size\", 3)\n properties[\"increase_factor\"] = results.get(\"increase_factor\", 0)\n self.model = properties[\"name\"] # regardless of the name of the folder, this will get the proper model name (i.e. <modelname>.cntk)\n\n # optional property\n properties[\"trainer\"] = results.get(\"trainer\", \"CNTK 2.2\")\n\n self._ensure_model_file()\n properties[\"size_mb\"] = round(os.path.getsize(self.model_file) / (1000 * 1000))\n\n return properties","def as_dict(self):\n result = {}\n for attr in self.__attr:\n result[attr] = getattr(self, attr)\n return result","def to_dict_model(self) -> dict:\n return dict((key, getattr(self, key)) for key in self.__mapper__.c.keys())","def get_properties():\n properties = dict()\n properties['size'] = list()\n properties['color'] = list()\n properties['quality'] = list()\n u = models.Size.query.all()\n for i in u:\n properties['size'].append(i.size_name)\n u = models.Color.query.all()\n for i in u:\n properties['color'].append(i.color_name)\n u = models.Quality.query.all()\n for i in u:\n properties['quality'].append(i.quality_name)\n return make_response(jsonify(properties))","def get_modelDict(self):\n return self.__modelDict","def attributes(self):\n return dict(self.__attributes)","def properties(self):\n return self._properties","def properties(self):\n return self._properties","def to_dict(self):\n result = {}\n for p in self.json_properties():\n value = getattr(self, p)\n if isinstance(value, datetime.datetime):\n value = value.strftime('%s%f')[:-3]\n result[Jsonifiable.transform_to_camelcase(p)] = value\n return result","def properties(self):\n return self._props","def properties(self):\n pass","def to_dict(self):\n d = {}\n for attr in self.__class__.attributes:\n d[attr] = getattr(self, attr)\n return d","def properties_get(self):\n return self._get('properties')","def _collect_properties(self):\n properties = {\n 'userid': self.user_id,\n 'title': self.get_fullname()\n }\n if not self.ogds_user:\n return properties\n\n for attribute_name in self.ogds_user_attributes:\n value = getattr(self.ogds_user, attribute_name)\n properties[attribute_name] = value\n return properties","def getPropertyDict(self):\n \n d = self.getChild('__properties')\n if d:\n return d.getDict()\n else:\n return {}","def get_attributes(self):\n return dict(self.attributes) # return the attributes","def get_attributes(self):\n return dict(self.attributes) # return the attributes","def get_attributes(self):\n return dict(self.attributes) # return the attributes","def to_dict(self, include=None):\n _MODEL = type(self)\n repr_dict = {}\n if include is None:\n include = []\n for name, prop in _MODEL._properties.iteritems():\n if hasattr(prop, 'public') and getattr(prop, 'public', False):\n include.append(name)\n\n for name in include:\n # check if this property is even allowed to be public\n # or has a value set\n if not hasattr(self, name):\n continue\n\n value = getattr(self, name)\n if type(getattr(_MODEL, name)) == ndb.StructuredProperty:\n if isinstance(value, list):\n items = []\n for item in value:\n items.append(item.to_dict(include=None))\n repr_dict[name] = items\n else:\n repr_dict[name] = value.to_dict(include=None)\n elif isinstance(value, date):\n repr_dict[name] = value.isoformat()\n elif isinstance(value, ndb.Key):\n repr_dict[name] = value.urlsafe()\n else:\n repr_dict[name] = value\n\n if self._key:\n repr_dict['key'] = self.get_key_urlsafe()\n return repr_dict","def to_dict(self):\n properties = {}\n for k in self.__dict__:\n if k == 'POSSIBLE_METHODS':\n continue\n if k == 'keysamplers':\n properties[k] = [i.to_dict() for i in self.__dict__[k] if hasattr(i,'to_dict')]\n elif k in {'pooler'}:\n properties[k] = self.__dict__[k].to_dict()\n else:\n properties[k] = deepcopy(self.__dict__[k])\n return properties","def get_all_properties(cls):\n return ['key', 'id'] + _.keys(cls._properties)","def get_properties(self):\n return self.name, self.author, self.description, self.fmu_type, self.version, self.guid, self.tool, self.numStates","def properties(self):\n\n return self._properties","def ToDict(self):\n atributes_dictionary = {}\n for key, value in self.__dict__.iteritems():\n atributes_dictionary[key] = value\n return atributes_dictionary","def properties(self):","def properties(self):","def properties(self):","def modelPropertiesDictionary(sql_row_list):\n \n properties_dictionary = \\\n {\n \"id\": sql_row_list[0],\n \"name\": sql_row_list[1],\n \"last_deploy_timestamp\": sql_row_list[2],\n \"active_version\": sql_row_list[3],\n \"build_id\": sql_row_list[4]\n };\n\n return properties_dictionary;","def as_dict(self):\n data = dict()\n for name in self.fields:\n val = getattr(self, name)\n if isinstance(val, Model):\n val = val.as_dict()\n elif isinstance(val, list) and val and isinstance(val[0], Model):\n val = [sub.as_dict() for sub in val]\n data[name] = val\n return data","def to_dict(self):\n if self._dict is not None:\n return self._dict\n\n result = {}\n for key in self.ATTRIBUTES:\n value = getattr(self, key)\n if value:\n result[key] = value\n self._dict = result\n return result","def properties(self) -> Optional[Mapping[str, str]]:\n return pulumi.get(self, \"properties\")","def properties(self) -> Optional[Mapping[str, str]]:\n return pulumi.get(self, \"properties\")","def to_dict(self):\n _dict = {}\n for f in self._meta.fields:\n if f.name == 'created':\n _dict[f.name] = str(f.value_from_object(self))\n else:\n _dict[f.name] = f.value_from_object(self)\n\n return _dict","def to_dict(self):\r\n return self.__dict__","def properties(self):\n return None","def properties(self):\n return None","def to_dict(self):\n return attr.asdict(self)","def as_dict(self):\n return self.__dict__","def _get_model_state(self) -> dict:\n return dict(model=self.model, kwargs=self._model_kwargs)","def dictify(self):\n return {\n \"name\" : self.name,\n \"lastname\" : self.lastname,\n \"phone\" : self.phone,\n \"email\" : self.email\n }","def to_dict(self):\n return {\n \"id\": self.id,\n \"name\": self.name,\n # \"created_by\": self.created_by,\n # \"created_on\": self.created_on,\n # \"modified_by\": self.modified_by,\n # \"modified_on\": self.modified_on\n }","def properties(self):\r\n return resources.Properties(self)","def attributes(self):\n params = self.model.param_array\n return {'parameters': params}","def properties(self, pk):\n return JsonResponse(self._get_properties(pk))","def to_dict(self):\n return vars(self)","def to_dict(self):\n\n # Check if is the right instance.\n if isinstance(self, db.Model):\n # construct a dictionary from column names and values.\n dict_representation = {c.name: getattr(self, c.name) for c in self.__table__.columns}\n return dict_representation\n else:\n raise AttributeError(type(self).__name__ + \" is not instance of \" + db.Model.__name__)","def bson_properties(self):\n return []","def to_dict(self):\n return {\n \"id\": self.id,\n \"name\": self.name\n }","def get_dict(self):\n return","def to_dict(self):\n return to_dict(self.__dict__)","def to_json(self):\n properties = self.to_dict()\n if isinstance(self, db.Model):\n properties['id'] = unicode(self.key().id())\n return json.dumps(properties)","def to_dict(self):","def to_dict(self):\n return self.__dict__","def to_dict(self):\n return self.__dict__","def to_dict(self):\n return self.__dict__","def to_dict(self):\n return self.__dict__","def to_dict(self):\n return self.__dict__","def to_dict(self):\n return self.__dict__","def get_attributes(self) -> Dict[str, str]:\n pass","def config(self) -> ModelConfigDict:\n return self.config_obj.to_dict()","def properties(self):\n return self.properties_with_uid[1:]","def to_dict(self):\n properties = {}\n for k in self.__dict__:\n if k in {'idsSoFar'}:\n continue\n else:\n properties[k] = deepcopy(self.__dict__[k])\n return properties","def to_dict(self):\n properties = {}\n for k in self.__dict__:\n if k in {'idsSoFar'}:\n continue\n else:\n properties[k] = deepcopy(self.__dict__[k])\n return properties","def to_dict(self):\n properties = {}\n for k in self.__dict__:\n if k in {'idsSoFar'}:\n continue\n else:\n properties[k] = deepcopy(self.__dict__[k])\n return properties","def serialise(self):\n return {\n 'id': self.id,\n 'category_id': self.category_id,\n 'name': self.name,\n 'description': self.description,\n 'quantity': self.quantity,\n 'price': self.price,\n 'user_id': self.user_id\n }","def getPropertiesAll():","def get_all_properties(self) -> dict:\n return self._request(\n \"post\",\n URL,\n json=attr.asdict(\n Body(\"getAllProperties\", API_VERSION),\n filter=attr.filters.exclude(attr.fields(Body).params),\n ),\n )","def model_info(self):\n if not self._model_info:\n self._load_model_info()\n try:\n data = json.loads(self._model_info)\n except (TypeError, ValueError):\n data = {}\n return data","def to_dict(self):\n return {\n 'name': self.get_name(),\n 'description': self.get_description()\n }","def serialize(self):\n return {\n 'id' : self.id,\n 'name' : self.name,\n }","def serialize(self):\n return {\n 'id' : self.id,\n 'name' : self.name,\n }","def as_dict(self):\n return self.__dict__","def to_dict(self):\r\n\r\n return {\r\n 'product_id': self.product_id,\r\n 'product_name': self.product_name\r\n }","def serialize(self):\n return {\n 'name' : self.name,\n 'id' : self.id,\n }","def asdict(self):\n return attr.asdict(self)","def to_dict(self) -> dict:","def getDict(self):\n res = {}\n for attr, value in self.__dict__.iteritems():\n if type(attr) is IntType or type(attr) is StringType or type(attr) is LongType or type(attr) is UnicodeType:\n res[attr] = value\n elif isinstance(attr, datetime.datetime):\n res[attr] = value.isoformat('-')\n \n return res","def attributes(self):\n return self.__dict.keys()","def dict(self):\n return self.__dict__","def dict(self):\n return self.__dict__","def dict(self):\n return self.__dict__","def dict(self):\n return self.__dict__","def dict(self):\n return self.__dict__","def dict(self):\n return self.__dict__","def dict(self):\n return self.__dict__","def as_dict(self):\n return {c.key: getattr(self, c.key)\n for c in inspect(self).mapper.column_attrs}"],"string":"[\n \"def to_dict(self):\\n return self.properties\",\n \"def to_dict(self):\\n return self.properties\",\n \"def get_properties(self):\\n return self.properties\",\n \"def asdict(self):\\n return self._prop_dict\",\n \"def json(self):\\n rv = {\\n prop: getattr(self, prop)\\n for prop in self.__properties__\\n if prop in vars(self)\\n }\\n rv.update(self._props)\\n return rv\",\n \"def get_properties(self):\\n return self.properties\",\n \"def get_properties():\",\n \"def getProperties():\",\n \"def properties(self):\\r\\n if self._properties is None:\\r\\n res = self._con.get(self._url, {'f':'json'})\\r\\n self._properties = PropertyMap(res)\\r\\n return self._properties\",\n \"def properties(self):\\r\\n if self._properties is None:\\r\\n res = self._con.get(self._url, {'f':'json'})\\r\\n self._properties = PropertyMap(res)\\r\\n return self._properties\",\n \"def getProperties(self):\\n return self.properties\",\n \"def __properties__(self) -> dict:\\r\\n parameters = [\\r\\n d for d in dir(self) if (d[0] != \\\"_\\\") and (d.count(\\\"set\\\") == 0)\\r\\n and (d.count(\\\"_c\\\") == 0) and (d.count(\\\"_f\\\") == 0)\\r\\n ]\\r\\n\\r\\n return self.__as_json__(parameters)\",\n \"def json_properties(self):\\n attributes = []\\n all = vars(self)\\n for var in all:\\n if var[:1] != '_':\\n attributes.append(var)\\n if isinstance(self, db.Model):\\n properties = self.properties().keys()\\n for property in properties:\\n if property[:1] != '_':\\n attributes.append(property)\\n return attributes\",\n \"def properties(self) -> Any:\\n return pulumi.get(self, \\\"properties\\\")\",\n \"def _properties(self) -> dict[str, dict[str, str]]:\\n schema = self.schema(by_alias=False)\\n if schema.get('properties') is not None:\\n return schema.get('properties', {})\\n return schema.get('definitions', {}).get(self.__class__.__name__, {}).get('properties', {})\",\n \"def get_model_properties(self):\\n properties = {}\\n\\n filename = self._get_data_filename(\\\"modelargs.json\\\")\\n with open(filename, \\\"r\\\") as f:\\n results = json.loads(f.read())\\n properties[\\\"image_size\\\"] = results.get(\\\"image_size\\\")\\n properties[\\\"num_classes\\\"] = results.get(\\\"num_classes\\\")\\n properties[\\\"model\\\"] = results.get(\\\"model\\\")\\n properties[\\\"name\\\"] = results.get(\\\"name\\\")\\n properties[\\\"filter_size\\\"] = results.get(\\\"filter_size\\\", 3)\\n properties[\\\"increase_factor\\\"] = results.get(\\\"increase_factor\\\", 0)\\n self.model = properties[\\\"name\\\"] # regardless of the name of the folder, this will get the proper model name (i.e. <modelname>.cntk)\\n\\n # optional property\\n properties[\\\"trainer\\\"] = results.get(\\\"trainer\\\", \\\"CNTK 2.2\\\")\\n\\n self._ensure_model_file()\\n properties[\\\"size_mb\\\"] = round(os.path.getsize(self.model_file) / (1000 * 1000))\\n\\n return properties\",\n \"def as_dict(self):\\n result = {}\\n for attr in self.__attr:\\n result[attr] = getattr(self, attr)\\n return result\",\n \"def to_dict_model(self) -> dict:\\n return dict((key, getattr(self, key)) for key in self.__mapper__.c.keys())\",\n \"def get_properties():\\n properties = dict()\\n properties['size'] = list()\\n properties['color'] = list()\\n properties['quality'] = list()\\n u = models.Size.query.all()\\n for i in u:\\n properties['size'].append(i.size_name)\\n u = models.Color.query.all()\\n for i in u:\\n properties['color'].append(i.color_name)\\n u = models.Quality.query.all()\\n for i in u:\\n properties['quality'].append(i.quality_name)\\n return make_response(jsonify(properties))\",\n \"def get_modelDict(self):\\n return self.__modelDict\",\n \"def attributes(self):\\n return dict(self.__attributes)\",\n \"def properties(self):\\n return self._properties\",\n \"def properties(self):\\n return self._properties\",\n \"def to_dict(self):\\n result = {}\\n for p in self.json_properties():\\n value = getattr(self, p)\\n if isinstance(value, datetime.datetime):\\n value = value.strftime('%s%f')[:-3]\\n result[Jsonifiable.transform_to_camelcase(p)] = value\\n return result\",\n \"def properties(self):\\n return self._props\",\n \"def properties(self):\\n pass\",\n \"def to_dict(self):\\n d = {}\\n for attr in self.__class__.attributes:\\n d[attr] = getattr(self, attr)\\n return d\",\n \"def properties_get(self):\\n return self._get('properties')\",\n \"def _collect_properties(self):\\n properties = {\\n 'userid': self.user_id,\\n 'title': self.get_fullname()\\n }\\n if not self.ogds_user:\\n return properties\\n\\n for attribute_name in self.ogds_user_attributes:\\n value = getattr(self.ogds_user, attribute_name)\\n properties[attribute_name] = value\\n return properties\",\n \"def getPropertyDict(self):\\n \\n d = self.getChild('__properties')\\n if d:\\n return d.getDict()\\n else:\\n return {}\",\n \"def get_attributes(self):\\n return dict(self.attributes) # return the attributes\",\n \"def get_attributes(self):\\n return dict(self.attributes) # return the attributes\",\n \"def get_attributes(self):\\n return dict(self.attributes) # return the attributes\",\n \"def to_dict(self, include=None):\\n _MODEL = type(self)\\n repr_dict = {}\\n if include is None:\\n include = []\\n for name, prop in _MODEL._properties.iteritems():\\n if hasattr(prop, 'public') and getattr(prop, 'public', False):\\n include.append(name)\\n\\n for name in include:\\n # check if this property is even allowed to be public\\n # or has a value set\\n if not hasattr(self, name):\\n continue\\n\\n value = getattr(self, name)\\n if type(getattr(_MODEL, name)) == ndb.StructuredProperty:\\n if isinstance(value, list):\\n items = []\\n for item in value:\\n items.append(item.to_dict(include=None))\\n repr_dict[name] = items\\n else:\\n repr_dict[name] = value.to_dict(include=None)\\n elif isinstance(value, date):\\n repr_dict[name] = value.isoformat()\\n elif isinstance(value, ndb.Key):\\n repr_dict[name] = value.urlsafe()\\n else:\\n repr_dict[name] = value\\n\\n if self._key:\\n repr_dict['key'] = self.get_key_urlsafe()\\n return repr_dict\",\n \"def to_dict(self):\\n properties = {}\\n for k in self.__dict__:\\n if k == 'POSSIBLE_METHODS':\\n continue\\n if k == 'keysamplers':\\n properties[k] = [i.to_dict() for i in self.__dict__[k] if hasattr(i,'to_dict')]\\n elif k in {'pooler'}:\\n properties[k] = self.__dict__[k].to_dict()\\n else:\\n properties[k] = deepcopy(self.__dict__[k])\\n return properties\",\n \"def get_all_properties(cls):\\n return ['key', 'id'] + _.keys(cls._properties)\",\n \"def get_properties(self):\\n return self.name, self.author, self.description, self.fmu_type, self.version, self.guid, self.tool, self.numStates\",\n \"def properties(self):\\n\\n return self._properties\",\n \"def ToDict(self):\\n atributes_dictionary = {}\\n for key, value in self.__dict__.iteritems():\\n atributes_dictionary[key] = value\\n return atributes_dictionary\",\n \"def properties(self):\",\n \"def properties(self):\",\n \"def properties(self):\",\n \"def modelPropertiesDictionary(sql_row_list):\\n \\n properties_dictionary = \\\\\\n {\\n \\\"id\\\": sql_row_list[0],\\n \\\"name\\\": sql_row_list[1],\\n \\\"last_deploy_timestamp\\\": sql_row_list[2],\\n \\\"active_version\\\": sql_row_list[3],\\n \\\"build_id\\\": sql_row_list[4]\\n };\\n\\n return properties_dictionary;\",\n \"def as_dict(self):\\n data = dict()\\n for name in self.fields:\\n val = getattr(self, name)\\n if isinstance(val, Model):\\n val = val.as_dict()\\n elif isinstance(val, list) and val and isinstance(val[0], Model):\\n val = [sub.as_dict() for sub in val]\\n data[name] = val\\n return data\",\n \"def to_dict(self):\\n if self._dict is not None:\\n return self._dict\\n\\n result = {}\\n for key in self.ATTRIBUTES:\\n value = getattr(self, key)\\n if value:\\n result[key] = value\\n self._dict = result\\n return result\",\n \"def properties(self) -> Optional[Mapping[str, str]]:\\n return pulumi.get(self, \\\"properties\\\")\",\n \"def properties(self) -> Optional[Mapping[str, str]]:\\n return pulumi.get(self, \\\"properties\\\")\",\n \"def to_dict(self):\\n _dict = {}\\n for f in self._meta.fields:\\n if f.name == 'created':\\n _dict[f.name] = str(f.value_from_object(self))\\n else:\\n _dict[f.name] = f.value_from_object(self)\\n\\n return _dict\",\n \"def to_dict(self):\\r\\n return self.__dict__\",\n \"def properties(self):\\n return None\",\n \"def properties(self):\\n return None\",\n \"def to_dict(self):\\n return attr.asdict(self)\",\n \"def as_dict(self):\\n return self.__dict__\",\n \"def _get_model_state(self) -> dict:\\n return dict(model=self.model, kwargs=self._model_kwargs)\",\n \"def dictify(self):\\n return {\\n \\\"name\\\" : self.name,\\n \\\"lastname\\\" : self.lastname,\\n \\\"phone\\\" : self.phone,\\n \\\"email\\\" : self.email\\n }\",\n \"def to_dict(self):\\n return {\\n \\\"id\\\": self.id,\\n \\\"name\\\": self.name,\\n # \\\"created_by\\\": self.created_by,\\n # \\\"created_on\\\": self.created_on,\\n # \\\"modified_by\\\": self.modified_by,\\n # \\\"modified_on\\\": self.modified_on\\n }\",\n \"def properties(self):\\r\\n return resources.Properties(self)\",\n \"def attributes(self):\\n params = self.model.param_array\\n return {'parameters': params}\",\n \"def properties(self, pk):\\n return JsonResponse(self._get_properties(pk))\",\n \"def to_dict(self):\\n return vars(self)\",\n \"def to_dict(self):\\n\\n # Check if is the right instance.\\n if isinstance(self, db.Model):\\n # construct a dictionary from column names and values.\\n dict_representation = {c.name: getattr(self, c.name) for c in self.__table__.columns}\\n return dict_representation\\n else:\\n raise AttributeError(type(self).__name__ + \\\" is not instance of \\\" + db.Model.__name__)\",\n \"def bson_properties(self):\\n return []\",\n \"def to_dict(self):\\n return {\\n \\\"id\\\": self.id,\\n \\\"name\\\": self.name\\n }\",\n \"def get_dict(self):\\n return\",\n \"def to_dict(self):\\n return to_dict(self.__dict__)\",\n \"def to_json(self):\\n properties = self.to_dict()\\n if isinstance(self, db.Model):\\n properties['id'] = unicode(self.key().id())\\n return json.dumps(properties)\",\n \"def to_dict(self):\",\n \"def to_dict(self):\\n return self.__dict__\",\n \"def to_dict(self):\\n return self.__dict__\",\n \"def to_dict(self):\\n return self.__dict__\",\n \"def to_dict(self):\\n return self.__dict__\",\n \"def to_dict(self):\\n return self.__dict__\",\n \"def to_dict(self):\\n return self.__dict__\",\n \"def get_attributes(self) -> Dict[str, str]:\\n pass\",\n \"def config(self) -> ModelConfigDict:\\n return self.config_obj.to_dict()\",\n \"def properties(self):\\n return self.properties_with_uid[1:]\",\n \"def to_dict(self):\\n properties = {}\\n for k in self.__dict__:\\n if k in {'idsSoFar'}:\\n continue\\n else:\\n properties[k] = deepcopy(self.__dict__[k])\\n return properties\",\n \"def to_dict(self):\\n properties = {}\\n for k in self.__dict__:\\n if k in {'idsSoFar'}:\\n continue\\n else:\\n properties[k] = deepcopy(self.__dict__[k])\\n return properties\",\n \"def to_dict(self):\\n properties = {}\\n for k in self.__dict__:\\n if k in {'idsSoFar'}:\\n continue\\n else:\\n properties[k] = deepcopy(self.__dict__[k])\\n return properties\",\n \"def serialise(self):\\n return {\\n 'id': self.id,\\n 'category_id': self.category_id,\\n 'name': self.name,\\n 'description': self.description,\\n 'quantity': self.quantity,\\n 'price': self.price,\\n 'user_id': self.user_id\\n }\",\n \"def getPropertiesAll():\",\n \"def get_all_properties(self) -> dict:\\n return self._request(\\n \\\"post\\\",\\n URL,\\n json=attr.asdict(\\n Body(\\\"getAllProperties\\\", API_VERSION),\\n filter=attr.filters.exclude(attr.fields(Body).params),\\n ),\\n )\",\n \"def model_info(self):\\n if not self._model_info:\\n self._load_model_info()\\n try:\\n data = json.loads(self._model_info)\\n except (TypeError, ValueError):\\n data = {}\\n return data\",\n \"def to_dict(self):\\n return {\\n 'name': self.get_name(),\\n 'description': self.get_description()\\n }\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'name' : self.name,\\n }\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'name' : self.name,\\n }\",\n \"def as_dict(self):\\n return self.__dict__\",\n \"def to_dict(self):\\r\\n\\r\\n return {\\r\\n 'product_id': self.product_id,\\r\\n 'product_name': self.product_name\\r\\n }\",\n \"def serialize(self):\\n return {\\n 'name' : self.name,\\n 'id' : self.id,\\n }\",\n \"def asdict(self):\\n return attr.asdict(self)\",\n \"def to_dict(self) -> dict:\",\n \"def getDict(self):\\n res = {}\\n for attr, value in self.__dict__.iteritems():\\n if type(attr) is IntType or type(attr) is StringType or type(attr) is LongType or type(attr) is UnicodeType:\\n res[attr] = value\\n elif isinstance(attr, datetime.datetime):\\n res[attr] = value.isoformat('-')\\n \\n return res\",\n \"def attributes(self):\\n return self.__dict.keys()\",\n \"def dict(self):\\n return self.__dict__\",\n \"def dict(self):\\n return self.__dict__\",\n \"def dict(self):\\n return self.__dict__\",\n \"def dict(self):\\n return self.__dict__\",\n \"def dict(self):\\n return self.__dict__\",\n \"def dict(self):\\n return self.__dict__\",\n \"def dict(self):\\n return self.__dict__\",\n \"def as_dict(self):\\n return {c.key: getattr(self, c.key)\\n for c in inspect(self).mapper.column_attrs}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7751993","0.7751993","0.73391134","0.7334895","0.7297356","0.727818","0.7159078","0.71578115","0.71494967","0.71494967","0.71283495","0.71275014","0.7122587","0.71079814","0.7060394","0.7043251","0.7034103","0.70233124","0.69635814","0.69586295","0.690053","0.6881568","0.6881568","0.6857664","0.68415916","0.68122137","0.680096","0.67914945","0.6757063","0.6753585","0.6741746","0.6741746","0.6741746","0.6735291","0.67126125","0.6697801","0.6695801","0.6689893","0.6680752","0.66802895","0.66802895","0.66802895","0.66547817","0.66495687","0.6633999","0.6619567","0.6619567","0.66156983","0.66049474","0.6590706","0.6590706","0.6590206","0.6587873","0.65861845","0.65822417","0.65794736","0.65792733","0.657747","0.6571183","0.65662557","0.65637356","0.6539919","0.65396816","0.65283066","0.65252614","0.6513477","0.65098846","0.65077883","0.65077883","0.65077883","0.65077883","0.65077883","0.65077883","0.6507418","0.6505772","0.65015876","0.64951885","0.64951885","0.64951885","0.64857763","0.6474329","0.6469453","0.64684683","0.6453606","0.6453024","0.6453024","0.6430734","0.6429058","0.6426903","0.64215595","0.64201874","0.6417152","0.6414739","0.6411571","0.6411571","0.6411571","0.6411571","0.6411571","0.6411571","0.6411571","0.64035517"],"string":"[\n \"0.7751993\",\n \"0.7751993\",\n \"0.73391134\",\n \"0.7334895\",\n \"0.7297356\",\n \"0.727818\",\n \"0.7159078\",\n \"0.71578115\",\n \"0.71494967\",\n \"0.71494967\",\n \"0.71283495\",\n \"0.71275014\",\n \"0.7122587\",\n \"0.71079814\",\n \"0.7060394\",\n \"0.7043251\",\n \"0.7034103\",\n \"0.70233124\",\n \"0.69635814\",\n \"0.69586295\",\n \"0.690053\",\n \"0.6881568\",\n \"0.6881568\",\n \"0.6857664\",\n \"0.68415916\",\n \"0.68122137\",\n \"0.680096\",\n \"0.67914945\",\n \"0.6757063\",\n \"0.6753585\",\n \"0.6741746\",\n \"0.6741746\",\n \"0.6741746\",\n \"0.6735291\",\n \"0.67126125\",\n \"0.6697801\",\n \"0.6695801\",\n \"0.6689893\",\n \"0.6680752\",\n \"0.66802895\",\n \"0.66802895\",\n \"0.66802895\",\n \"0.66547817\",\n \"0.66495687\",\n \"0.6633999\",\n \"0.6619567\",\n \"0.6619567\",\n \"0.66156983\",\n \"0.66049474\",\n \"0.6590706\",\n \"0.6590706\",\n \"0.6590206\",\n \"0.6587873\",\n \"0.65861845\",\n \"0.65822417\",\n \"0.65794736\",\n \"0.65792733\",\n \"0.657747\",\n \"0.6571183\",\n \"0.65662557\",\n \"0.65637356\",\n \"0.6539919\",\n \"0.65396816\",\n \"0.65283066\",\n \"0.65252614\",\n \"0.6513477\",\n \"0.65098846\",\n \"0.65077883\",\n \"0.65077883\",\n \"0.65077883\",\n \"0.65077883\",\n \"0.65077883\",\n \"0.65077883\",\n \"0.6507418\",\n \"0.6505772\",\n \"0.65015876\",\n \"0.64951885\",\n \"0.64951885\",\n \"0.64951885\",\n \"0.64857763\",\n \"0.6474329\",\n \"0.6469453\",\n \"0.64684683\",\n \"0.6453606\",\n \"0.6453024\",\n \"0.6453024\",\n \"0.6430734\",\n \"0.6429058\",\n \"0.6426903\",\n \"0.64215595\",\n \"0.64201874\",\n \"0.6417152\",\n \"0.6414739\",\n \"0.6411571\",\n \"0.6411571\",\n \"0.6411571\",\n \"0.6411571\",\n \"0.6411571\",\n \"0.6411571\",\n \"0.6411571\",\n \"0.64035517\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24577,"cells":{"query":{"kind":"string","value":"Returns the string representation of the model"},"document":{"kind":"string","value":"def to_str(self):\n return pprint.pformat(self.to_dict())"},"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 __str__(self):\n return super().__str__() + self.model.__str__()","def __str__(self) -> str:\n # noinspection PyUnresolvedReferences\n opts = self._meta\n if self.name_field:\n result = str(opts.get_field(self.name_field).value_from_object(self))\n else:\n model_fields = get_model_fields(\n opts.model,\n foreign=False,\n m2m=False,\n exclude=self.exclude_from_str\n )\n # TODO: replace the above with the below to remove the get_model_fields call:\n # model_fields = [\n # f for f in opts.get_fields()\n # if f.concrete\n # and not (f.primary_key or f.is_relation or f.name in self.exclude_from_str)\n # ]\n result = \" \".join(\n [\n str(fld.value_from_object(self))\n for fld in model_fields\n if fld.value_from_object(self)\n ]\n )\n return result.strip() or super().__str__()","def __str__(self):\n return '%s%s' % (self.name, ' - %s' % self.model if self.model else '')","def __str__(self):\n model = self._meta.verbose_name.title()\n return f\"{model:s}: {self.name:s}\"","def __str__(self):\n model = self._meta.verbose_name.title()\n return f\"{model:s}: {self.name:s}\"","def __repr__(self):\n\n mod = f\"{self.__class__.__name__} Model\"\n try:\n mod += f': {self.filename}'\n except AttributeError:\n pass\n s = [mod]\n for name, v in self.metadata.items():\n s += [f\"{name:16} : {v}\"]\n return '\\n'.join(s)","def __str__(self):\n \n res = ['>>> Model %(model_name)s <<<']\n res.append('')\n res.append('Independent parameters:')\n res.append('-----------------------')\n res.append('')","def __str__(self):\n return \"DataModel(name={},attributes={},description={})\".format(\n self.name, {a.name: str(a) for a in self.attributes}, self.description\n )","def model_info(self) -> str:\n return self._model_info(self.model).decode(\"utf-8\")","def __str__(self):\n return str(self.serialize())","def __str__ (self) :\n\n return self.as_string()","def __str__(self):\n\n return self.toString()","def __str__(self):\n msg = [\n f'{self.model=}',\n f'{self.field=}',\n f'{self.fxx=}',\n f'{self.date=}',\n f'{self.priority=}',\n ]\n return '\\n'.join(msg)","def __str__(self):\n model = self._meta.verbose_name.title()\n title = self.extended_object.get_title()\n return f\"{model:s}: {title:s}\"","def __repr__(self):\n return grid_search_to_str(self.model)","def __str__(self):\n return self.toString()","def __str__(self):\n return str(self.__dict__)","def __str__(self):\n return str(self.__dict__)","def to_representation(self) -> str:\n raise NotImplementedError()","def __str__(self):\n return str(self.obj)","def __str__(self):\n return self.make_flat()","def dump_model(self):","def __str__(self):\n return str(self.__dict__['_obj'])","def __str__(self) -> str:\n model_str = [\"\\nModel info:\\n\", \" Unimodal encoder:\\n\"]\n\n for modality in range(self.num_modalities):\n model_str.append(f\" ({modality + 1}) {self.unimodal_encoder[modality]}\")\n\n model_str.append(\"\\n\\n Unimodal decoder:\\n\")\n for modality in range(self.num_modalities):\n model_str.append(f\" ({modality + 1}) {self.unimodal_decoder[modality]}\")\n\n if self.multimodal_decoder is not None:\n model_str.append(\"\\n\\n Multimodal decoder:\\n\")\n model_str.append(f\" {self.multimodal_decoder}\")\n\n return \"\".join(model_str)","def __repr__(self):\n s = 'text model name: ' + self.name + '\\n'\n s += ' number of words: ' + str(len(self.words)) + '\\n'\n s += ' number of word lengths: ' + str(len(self.word_lengths)) + '\\n'\n s += ' number of stems: ' + str(len(self.stems)) + '\\n'\n s += ' number of sentence lengths: ' + str(len(self.sentence_lengths)) + '\\n'\n s += ' most common words: ' + str(self.common_word) + '\\n'\n\n return s","def to_string(self):\r\n return self.__str__()","def __repr__(self):\n return '<ModelSignature(model_name=%r)>' % self.model_name","def __repr__(self):\n return '<ModelSignature(model_name=%r)>' % self.model_name","def __str__(self):\n return str(self.get_data())","def __str__(self):\n\n return self.raw_field","def __str__(self):\n return f\"model {self._name}\"","def serialize(self):\n\n\t\treturn str(self)","def __repr__(self):\n \n s = 'text model name: ' + self.name + '\\n' \n s += ' number of words: ' + str(len(self.words)) + '\\n'\n s += ' number of word lengths: ' + str(len(self.word_lengths)) + '\\n'\n s += ' number of sentence lengths: ' + str(len(self.sentence_lengths)) + '\\n'\n s += ' number of word stems: ' + str(len(self.stems)) + '\\n'\n s += ' number of commas counts: ' + str(len(self.commas_per_sentence)) + '\\n'\n return s","def __str__(self):\n return self.get_str()","def serialize(self):\n\n return str(self)","def __str__(self) -> str:\n if self.name_field:\n return str(getattr(self, self.name_field))\n # noinspection PyUnresolvedReferences\n data = [\n # Collect the string representations of related objects.\n # getattr(self, fk_field.attname) and\n # fk_field.value_from_object(self) would only return the primary\n # key of the related object.\n str(getattr(self, fk_field.name))\n for fk_field in get_model_fields(\n self._meta.model, base=False, foreign=True, m2m=False\n )\n if not fk_field.null\n ]\n if len(data) < 2:\n # Cannot build a more meaningful representation than the default.\n return super().__str__()\n else:\n template = \"{}\" + \" ({})\" * (len(data) - 1)\n return template.format(*data)","def __str__(self):\n return self.s","def __str__(self):\n return self.__repr__()","def __str__(self):\n return self.__repr__()","def __str__(self):\n return self.__repr__()","def __str__(self):\n return self.__repr__()","def __str__(self):\n return self.__repr__()","def __repr__(self):\n\n # info string\n info = self.model.__repr__()\n info += \"\\n=========================\\n\"\n info += f\"Train data length:\\t\\t{ len(self.train_dataset) }\\n\"\n info += f\"Eval sata length:\\t\\t{ len(self.eval_dataset) }\\n\"\n info += f\"Optimizer:\\t\\t\\t\\t{ str(self.optimizer).split('(')[0] }\\n\"\n info += f\"Criterion:\\t\\t\\t\\t{ str(self.criterion).split('(')[0] }\\n\"\n info += f\"Training Environment:\\t{ self.device.type }\\n\"\n info += f\"Show information:\\t\\t{ 'True' if self.info else 'False' }\\n\"\n info += \"=========================\\n\"\n\n return info","def __repr__(self):\n s = 'text model name: ' + self.name + '\\n'\n s += ' number of words: ' + str(len(self.words)) + '\\n'\n s += ' number of word lengths: ' + str(len(self.word_lengths)) + '\\n'\n s += ' number of stems: ' + str(len(self.stems)) + '\\n'\n s += ' number of sentence lengths: ' + str(len(self.sentence_lengths))\\\n + '\\n'\n s += ' number of punctuation types: ' + str(len(self.punctuation))\n return s","def dumps(self, indent=0):\n outstr = \" \"*indent + \"MewloDbModel object '{0}' attribute values:\\n\".format(self.__class__.__name__)\n public_props = (name for name in dir(object) if not name.startswith('_'))\n for name in public_props:\n outstr += \" \"*indent + \"{0}: {1}\\n\".format(name, str(getattr(self,name)))\n return outstr","def __str__(self):\n model = self._meta.verbose_name.title()\n title = self.title or str(_(\"Empty title\"))\n\n return f\"{model:s}: {title:s}\"","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()"],"string":"[\n \"def __str__(self):\\n return super().__str__() + self.model.__str__()\",\n \"def __str__(self) -> str:\\n # noinspection PyUnresolvedReferences\\n opts = self._meta\\n if self.name_field:\\n result = str(opts.get_field(self.name_field).value_from_object(self))\\n else:\\n model_fields = get_model_fields(\\n opts.model,\\n foreign=False,\\n m2m=False,\\n exclude=self.exclude_from_str\\n )\\n # TODO: replace the above with the below to remove the get_model_fields call:\\n # model_fields = [\\n # f for f in opts.get_fields()\\n # if f.concrete\\n # and not (f.primary_key or f.is_relation or f.name in self.exclude_from_str)\\n # ]\\n result = \\\" \\\".join(\\n [\\n str(fld.value_from_object(self))\\n for fld in model_fields\\n if fld.value_from_object(self)\\n ]\\n )\\n return result.strip() or super().__str__()\",\n \"def __str__(self):\\n return '%s%s' % (self.name, ' - %s' % self.model if self.model else '')\",\n \"def __str__(self):\\n model = self._meta.verbose_name.title()\\n return f\\\"{model:s}: {self.name:s}\\\"\",\n \"def __str__(self):\\n model = self._meta.verbose_name.title()\\n return f\\\"{model:s}: {self.name:s}\\\"\",\n \"def __repr__(self):\\n\\n mod = f\\\"{self.__class__.__name__} Model\\\"\\n try:\\n mod += f': {self.filename}'\\n except AttributeError:\\n pass\\n s = [mod]\\n for name, v in self.metadata.items():\\n s += [f\\\"{name:16} : {v}\\\"]\\n return '\\\\n'.join(s)\",\n \"def __str__(self):\\n \\n res = ['>>> Model %(model_name)s <<<']\\n res.append('')\\n res.append('Independent parameters:')\\n res.append('-----------------------')\\n res.append('')\",\n \"def __str__(self):\\n return \\\"DataModel(name={},attributes={},description={})\\\".format(\\n self.name, {a.name: str(a) for a in self.attributes}, self.description\\n )\",\n \"def model_info(self) -> str:\\n return self._model_info(self.model).decode(\\\"utf-8\\\")\",\n \"def __str__(self):\\n return str(self.serialize())\",\n \"def __str__ (self) :\\n\\n return self.as_string()\",\n \"def __str__(self):\\n\\n return self.toString()\",\n \"def __str__(self):\\n msg = [\\n f'{self.model=}',\\n f'{self.field=}',\\n f'{self.fxx=}',\\n f'{self.date=}',\\n f'{self.priority=}',\\n ]\\n return '\\\\n'.join(msg)\",\n \"def __str__(self):\\n model = self._meta.verbose_name.title()\\n title = self.extended_object.get_title()\\n return f\\\"{model:s}: {title:s}\\\"\",\n \"def __repr__(self):\\n return grid_search_to_str(self.model)\",\n \"def __str__(self):\\n return self.toString()\",\n \"def __str__(self):\\n return str(self.__dict__)\",\n \"def __str__(self):\\n return str(self.__dict__)\",\n \"def to_representation(self) -> str:\\n raise NotImplementedError()\",\n \"def __str__(self):\\n return str(self.obj)\",\n \"def __str__(self):\\n return self.make_flat()\",\n \"def dump_model(self):\",\n \"def __str__(self):\\n return str(self.__dict__['_obj'])\",\n \"def __str__(self) -> str:\\n model_str = [\\\"\\\\nModel info:\\\\n\\\", \\\" Unimodal encoder:\\\\n\\\"]\\n\\n for modality in range(self.num_modalities):\\n model_str.append(f\\\" ({modality + 1}) {self.unimodal_encoder[modality]}\\\")\\n\\n model_str.append(\\\"\\\\n\\\\n Unimodal decoder:\\\\n\\\")\\n for modality in range(self.num_modalities):\\n model_str.append(f\\\" ({modality + 1}) {self.unimodal_decoder[modality]}\\\")\\n\\n if self.multimodal_decoder is not None:\\n model_str.append(\\\"\\\\n\\\\n Multimodal decoder:\\\\n\\\")\\n model_str.append(f\\\" {self.multimodal_decoder}\\\")\\n\\n return \\\"\\\".join(model_str)\",\n \"def __repr__(self):\\n s = 'text model name: ' + self.name + '\\\\n'\\n s += ' number of words: ' + str(len(self.words)) + '\\\\n'\\n s += ' number of word lengths: ' + str(len(self.word_lengths)) + '\\\\n'\\n s += ' number of stems: ' + str(len(self.stems)) + '\\\\n'\\n s += ' number of sentence lengths: ' + str(len(self.sentence_lengths)) + '\\\\n'\\n s += ' most common words: ' + str(self.common_word) + '\\\\n'\\n\\n return s\",\n \"def to_string(self):\\r\\n return self.__str__()\",\n \"def __repr__(self):\\n return '<ModelSignature(model_name=%r)>' % self.model_name\",\n \"def __repr__(self):\\n return '<ModelSignature(model_name=%r)>' % self.model_name\",\n \"def __str__(self):\\n return str(self.get_data())\",\n \"def __str__(self):\\n\\n return self.raw_field\",\n \"def __str__(self):\\n return f\\\"model {self._name}\\\"\",\n \"def serialize(self):\\n\\n\\t\\treturn str(self)\",\n \"def __repr__(self):\\n \\n s = 'text model name: ' + self.name + '\\\\n' \\n s += ' number of words: ' + str(len(self.words)) + '\\\\n'\\n s += ' number of word lengths: ' + str(len(self.word_lengths)) + '\\\\n'\\n s += ' number of sentence lengths: ' + str(len(self.sentence_lengths)) + '\\\\n'\\n s += ' number of word stems: ' + str(len(self.stems)) + '\\\\n'\\n s += ' number of commas counts: ' + str(len(self.commas_per_sentence)) + '\\\\n'\\n return s\",\n \"def __str__(self):\\n return self.get_str()\",\n \"def serialize(self):\\n\\n return str(self)\",\n \"def __str__(self) -> str:\\n if self.name_field:\\n return str(getattr(self, self.name_field))\\n # noinspection PyUnresolvedReferences\\n data = [\\n # Collect the string representations of related objects.\\n # getattr(self, fk_field.attname) and\\n # fk_field.value_from_object(self) would only return the primary\\n # key of the related object.\\n str(getattr(self, fk_field.name))\\n for fk_field in get_model_fields(\\n self._meta.model, base=False, foreign=True, m2m=False\\n )\\n if not fk_field.null\\n ]\\n if len(data) < 2:\\n # Cannot build a more meaningful representation than the default.\\n return super().__str__()\\n else:\\n template = \\\"{}\\\" + \\\" ({})\\\" * (len(data) - 1)\\n return template.format(*data)\",\n \"def __str__(self):\\n return self.s\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __repr__(self):\\n\\n # info string\\n info = self.model.__repr__()\\n info += \\\"\\\\n=========================\\\\n\\\"\\n info += f\\\"Train data length:\\\\t\\\\t{ len(self.train_dataset) }\\\\n\\\"\\n info += f\\\"Eval sata length:\\\\t\\\\t{ len(self.eval_dataset) }\\\\n\\\"\\n info += f\\\"Optimizer:\\\\t\\\\t\\\\t\\\\t{ str(self.optimizer).split('(')[0] }\\\\n\\\"\\n info += f\\\"Criterion:\\\\t\\\\t\\\\t\\\\t{ str(self.criterion).split('(')[0] }\\\\n\\\"\\n info += f\\\"Training Environment:\\\\t{ self.device.type }\\\\n\\\"\\n info += f\\\"Show information:\\\\t\\\\t{ 'True' if self.info else 'False' }\\\\n\\\"\\n info += \\\"=========================\\\\n\\\"\\n\\n return info\",\n \"def __repr__(self):\\n s = 'text model name: ' + self.name + '\\\\n'\\n s += ' number of words: ' + str(len(self.words)) + '\\\\n'\\n s += ' number of word lengths: ' + str(len(self.word_lengths)) + '\\\\n'\\n s += ' number of stems: ' + str(len(self.stems)) + '\\\\n'\\n s += ' number of sentence lengths: ' + str(len(self.sentence_lengths))\\\\\\n + '\\\\n'\\n s += ' number of punctuation types: ' + str(len(self.punctuation))\\n return s\",\n \"def dumps(self, indent=0):\\n outstr = \\\" \\\"*indent + \\\"MewloDbModel object '{0}' attribute values:\\\\n\\\".format(self.__class__.__name__)\\n public_props = (name for name in dir(object) if not name.startswith('_'))\\n for name in public_props:\\n outstr += \\\" \\\"*indent + \\\"{0}: {1}\\\\n\\\".format(name, str(getattr(self,name)))\\n return outstr\",\n \"def __str__(self):\\n model = self._meta.verbose_name.title()\\n title = self.title or str(_(\\\"Empty title\\\"))\\n\\n return f\\\"{model:s}: {title:s}\\\"\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8585678","0.7814723","0.77902746","0.7750817","0.7750817","0.7713574","0.7699132","0.7670784","0.76510423","0.7600937","0.7582941","0.7570682","0.75406617","0.75233835","0.75168735","0.75013274","0.74877244","0.74877244","0.74700385","0.7451798","0.7446068","0.7442057","0.74369466","0.7413879","0.74063677","0.73830664","0.73619455","0.73619455","0.73310417","0.7327266","0.7324422","0.73114437","0.7310758","0.73026216","0.73002195","0.7294551","0.72921115","0.72900194","0.72900194","0.72900194","0.72900194","0.72900194","0.72813886","0.72624916","0.72512025","0.7244748","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286","0.7226286"],"string":"[\n \"0.8585678\",\n \"0.7814723\",\n \"0.77902746\",\n \"0.7750817\",\n \"0.7750817\",\n \"0.7713574\",\n \"0.7699132\",\n \"0.7670784\",\n \"0.76510423\",\n \"0.7600937\",\n \"0.7582941\",\n \"0.7570682\",\n \"0.75406617\",\n \"0.75233835\",\n \"0.75168735\",\n \"0.75013274\",\n \"0.74877244\",\n \"0.74877244\",\n \"0.74700385\",\n \"0.7451798\",\n \"0.7446068\",\n \"0.7442057\",\n \"0.74369466\",\n \"0.7413879\",\n \"0.74063677\",\n \"0.73830664\",\n \"0.73619455\",\n \"0.73619455\",\n \"0.73310417\",\n \"0.7327266\",\n \"0.7324422\",\n \"0.73114437\",\n \"0.7310758\",\n \"0.73026216\",\n \"0.73002195\",\n \"0.7294551\",\n \"0.72921115\",\n \"0.72900194\",\n \"0.72900194\",\n \"0.72900194\",\n \"0.72900194\",\n \"0.72900194\",\n \"0.72813886\",\n \"0.72624916\",\n \"0.72512025\",\n \"0.7244748\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\",\n \"0.7226286\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24578,"cells":{"query":{"kind":"string","value":"For `print` and `pprint`"},"document":{"kind":"string","value":"def __repr__(self):\n return self.to_str()"},"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 pprint(*args, **kwargs):\n if PRINTING:\n print(*args, **kwargs)","def print_out():\n pass","def custom_print(*objects):\n print(*objects, sep=OFS, end=ORS)","def _print(self, *args):\n return _ida_hexrays.vd_printer_t__print(self, *args)","def _printable(self):\n pass","def _print_custom(self):\n pass","def pypprint(*args, **kwargs): # type: ignore\n from typing import Iterable\n\n if len(args) != 1:\n print(*args, **kwargs)\n return\n x = args[0]\n if isinstance(x, dict):\n for k, v in x.items():\n print(f\"{k}:\", v, **kwargs)\n elif isinstance(x, Iterable) and not isinstance(x, str):\n for i in x:\n print(i, **kwargs)\n else:\n print(x, **kwargs)","def pprint(self):\n # just here for defining the interface; work is done in subclasses\n pass","def print(*args, **kwargs):\n with P_LOCK:\n __builtins__.print(*args, **kwargs)","def print(self):\n # Your implementation here","def p(value):\n pp.pprint(value)","def static_print(*args, __p=print, **kwargs):\n __p(*args, **kwargs)","def print(self, *args, **kwargs):\n print(*args, **kwargs)","def pprint(self):\n print(self.pprint_str())","def pprint(obj):\n for argname in sorted([x for x in dir(obj) if not x.startswith('__')]):\n # Skip callables\n if hasattr(getattr(obj, argname), '__call__'):\n continue\n print(\"{} : {}\".format(argname, getattr(obj, argname)))","def print_(self, s: str) -> None:","def my_pprint(obj, intend = 0):\n if isinstance(obj, dict):\n for key, value in obj.items():\n print(intend*\" \"+str(key)+\" : \")\n my_pprint(value, intend = intend + 4)\n print()\n elif isinstance(obj, list):\n for value in obj:\n my_pprint(value, intend = intend + 4)\n print()\n elif isinstance(obj, bytes):\n print(\"<binary data>\")\n \n else:\n try:\n print(intend*\" \"+str(obj))\n except UnicodeDecodeError:\n print(intend*\" \"\"<?>\")","def test_print(chikin):\n chikin.print()","def _print(self, text):\n\t\tif self.verbose:\n\t\t\tprint text","def out(*args):\r\n print(*args)","def __pprint(object, stream=None, indent=1, width=80, depth=None):\n printer = PrettyPrinterExt(\n stream=stream, indent=indent, width=width, depth=depth)\n printer.pprint(object)","def DumpPprint(data):\n #NOTE(g): Import is done here, instead of the top of the file, to not require this module if it is not used\n import pprint\n \n text = pprint.pformat(data)\n \n return text","def repl_print_statements():\n pass","def test_03_pass_print(self):\n print('Hello World!')","def p(self):\n self.printstdout = True","def print(*args, **kwargs):\n new_args = []\n for arg in args:\n if builtins.isinstance(arg, models.Point):\n new_args.append(\"({0}, {1})\".format(arg.x, arg.y))\n else:\n new_args.append(arg)\n\n builtins.print(*new_args, **kwargs)","def real_print(*args, **kwargs):\n\n kwargs.setdefault('file', real_stdout)\n _python_print_function(*args, **kwargs)","def to_print_out(self):\n self.error_throw('output')\n\n if self.rank_method == methods_of_ranking[3]: #'diversified_ranking'\n self.output_div('print')\n else:\n self.output('print')","def debug_print(debug_data):\n if DEBUG_MODE == \"true\":\n pp.pprint(debug_data)","def print(self):\r\n self.print_avec_separateur()","def pprint(self):\r\n for i in self.items():\r\n print '%s => %r'%i","def pprint(self, parameter_s=''):\n ptformatter = self.shell.display_formatter.formatters['text/plain']\n ptformatter.pprint = bool(1 - ptformatter.pprint)\n print('Pretty printing has been turned',\n ['OFF','ON'][ptformatter.pprint])","def print(self):\n print(self.pretty_str())","def test_print4(self):\n writer = StringIO()\n collatz_print(writer, 1, 1, 1)\n self.assertEqual(writer.getvalue(), \"1 1 1\\n\")","def eprint(*args, **kwargs):\n\tprint(*args, file=sys.stderr, **kwargs)","def _print(self, *args, **kwargs) -> None:\n # Only print in verbose mode\n if self._verbose:\n arglist = list(args)\n arglist[0] = f\"[buddy-{self._experiment_name}] {args[0]}\"\n print(*arglist, **kwargs)","def use_pypprint_for_implicit_print(self) -> None:\n if self.implicit_print is not None:\n self.implicit_print.func.id = \"pypprint\" # type: ignore\n # Make sure we import it later\n self.undefined.add(\"pypprint\")","def test_print(self):\n writer = StringIO()\n collatz_print(writer, 1, 10, 20)\n self.assertEqual(writer.getvalue(), \"1 10 20\\n\")","def pprint(self):\n return pformat(repr(self))","def printer(message):\n if VERBOSITY:\n pprint(message)","def rec_print(p):\n if len(p) == 0:\n return\n t = p.pop(0)\n print t\n rec_print(p)","def pformat(object):\r\n return PrettyPrinter().pformat(object)","def printc(*a, **kw):\n print(*a, **kw)","def pr(x):\n Card.print_pretty_cards(x)","def debug_print(self, *content):\n if self.debug:\n print(*content)","def pprint(object, stream=None):\r\n printer = PrettyPrinter(stream=stream)\r\n printer.pprint(object)","def safe_print(*objs, errors=\"replace\"):\n\tprint(*(to_stdout(str(o), errors) for o in objs))","def magic_Pprint(self, parameter_s=''):\n \n self.shell.outputcache.Pprint = 1 - self.shell.outputcache.Pprint\n print 'Pretty printing has been turned', \\\n ['OFF','ON'][self.shell.outputcache.Pprint]","def print_output(tree):\n print_value(tree)\n print_tree(tree)","def _Print(self, t):\n self.RaiseError(t, \"Print not supported\")","def vprint(*args, **kwargs ):\n\n forceprint = False\n for key in kwargs:\n if key == \"forceprint\":\n forceprint =kwargs[key]\n \n line = ''\n if debug or forceprint : \n for arg in args:\n line += str(arg) +\" \"\n log = open(exepath + 'pyframe.log', 'a') \n log.write(line + \"\\n\")\n log.close() \n print line","def eprint(*pargs, **kargs):\n print('\\u001b[31m', end='', file=sys.stderr)\n print(*pargs, file=sys.stderr, **kargs)\n print('\\u001b[0m', end='', file=sys.stderr)","def printer(obj, ident=''):\n import inspect\n print ident + obj.__class__.__name__.upper()\n ident += ' '\n lists = []\n for name in dir(obj):\n elem = getattr(obj, name)\n if isinstance(elem, list) and name != u'decoded_content':\n lists.append(elem)\n elif not inspect.ismethod(elem):\n if not name.startswith('__'):\n if name == u'data' and elem:\n print ident + u'data = '\n printer(elem, ident + ' ')\n else:\n print ident + u'%s\\t= %s' % (name, getattr(obj, name))\n for l in lists:\n for i in l:\n printer(i, ident + ' ')","def printer(obj, ident=''):\n import inspect\n print ident + obj.__class__.__name__.upper()\n ident += ' '\n lists = []\n for name in dir(obj):\n elem = getattr(obj, name)\n if isinstance(elem, list) and name != u'decoded_content':\n lists.append(elem)\n elif not inspect.ismethod(elem):\n if not name.startswith('__'):\n if name == u'data' and elem:\n print ident + u'data = '\n printer(elem, ident + ' ')\n else:\n print ident + u'%s\\t= %s' % (name, getattr(obj, name))\n for l in lists:\n for i in l:\n printer(i, ident + ' ')","def _print(self, *args):\n return _ida_hexrays.qstring_printer_t__print(self, *args)","def pprint(self):\n def pprintStr(node):\n s = \"(\" + str(node.value) \n for action in node.children:\n s = s + \", \" + pprintStr(node.children[action])\n s = s + \")\"\n return s\n\n print pprintStr(self)","def hook_print():\n sys.stdout = PrintHook()","def cmdPrint( self, *args):\n return self.cmd( *args, **{ 'verbose': True } )","def print_list(self):\r\n pass","def debugprint(obj, depth=-1, print_type=False,\r\n file=None, ids='CHAR', stop_on_name=False):\r\n if file == 'str':\r\n _file = StringIO()\r\n elif file is None:\r\n _file = sys.stdout\r\n else:\r\n _file = file\r\n done = dict()\r\n results_to_print = []\r\n order = []\r\n if isinstance(obj, gof.Variable):\r\n results_to_print.append(obj)\r\n elif isinstance(obj, gof.Apply):\r\n results_to_print.extend(obj.outputs)\r\n elif isinstance(obj, Function):\r\n results_to_print.extend(obj.maker.fgraph.outputs)\r\n order = obj.maker.fgraph.toposort()\r\n elif isinstance(obj, (list, tuple)):\r\n results_to_print.extend(obj)\r\n elif isinstance(obj, gof.FunctionGraph):\r\n results_to_print.extend(obj.outputs)\r\n order = obj.toposort()\r\n elif isinstance(obj, (int, long, float, numpy.ndarray)):\r\n print obj\r\n else:\r\n raise TypeError(\"debugprint cannot print an object of this type\", obj)\r\n for r in results_to_print:\r\n debugmode.debugprint(r, depth=depth, done=done, print_type=print_type,\r\n file=_file, order=order, ids=ids,\r\n stop_on_name=stop_on_name)\r\n if file is _file:\r\n return file\r\n elif file == 'str':\r\n return _file.getvalue()\r\n else:\r\n _file.flush()","def _get_print_fn(file=sys.stdout):\n def _print_fn(op, xin,):\n for attr in op.attrs:\n temp = getattr(xin, attr)\n if callable(temp):\n pmsg = temp()\n else:\n pmsg = temp\n print(op.message, attr, '=', pmsg, file=file)\n return _print_fn","def test_print1(self):\n writer = StringIO()\n collatz_print(writer, 100, 200, 125)\n self.assertEqual(writer.getvalue(), \"100 200 125\\n\")","def printOutput(self):\n pass","def _print(self, *args):\n return _ida_hexrays.cnumber_t__print(self, *args)","def setPrint():\n (e,d,sr,sw) = codecs.lookup('utf-8')\n unicode_to_utf8 = sw(sys.stdout)\n sys.stdout = unicode_to_utf8","def pr(string, verbose):\n if(verbose):\n print(string)","def print(*args, sep=\" \"):\n pass","def printv(self, *arg):\n if self.verbose:\n print(*arg)","def print(self):\n\n print(self)","def _p(self, *args, level=2, **kwargs):\n if self._verbosity >= level:\n print(*args, **kwargs)","def test_print2(self):\n writer = StringIO()\n collatz_print(writer, 201, 210, 89)\n self.assertEqual(writer.getvalue(), \"201 210 89\\n\")","def print_pointers(self):\n\n ### FILL IN ###","def foo_printer(self):\n print(\"\\nHi I'm {}\".format(self.foo))","def printed(method):\n\t\tdef wrapper(cls, *args):\n\t\t\tif cls.verbose:\n\t\t\t\treturn method(cls, *args)\n\t\treturn wrapper","def print_me(self, tabs=0, tab=' '):\n pre = tab*tabs\n print(pre+'Producer:')\n print(pre+' produces:', self._produces)\n print(pre+' consumes:', self._consumes)\n print(pre+' transfer:', self._transfer)\n print(pre+' capacity:', self._capacity)","def _print(cls, quad):\n\t\tprint(\"\\nLIGHT OUTPUT:\\n<<<<{}>>>>\".format(ast.literal_eval(str(cls.get_address_value(quad.result)))))\n\t\tprint(\"END\")\n\n\t\tvar = cls.get_address_value(quad.result)\n\t\tif isinstance(var, collections.Iterable):\n\t\t\tprint(\"DEEP COPY\")\n\t\t\tcls.print_queue.enqueue(copy.deepcopy(var))\n\t\telse:\n\t\t\tcls.print_queue.enqueue(var)","def printout(*args, **kwargs):\n console_print(sys.stdout, *args, **kwargs)","def pprint(x):\n if is_theano_object(x):\n return _gettheano().printing.pprint(x)\n else:\n return str(x)","def PrettyPrint(self):\r\n print(self.data)\r\n return","def print(self):\n self.print_avec_separateur(\" \")","def eprint(*args, **kwargs):\n print(*args, file=sys.stderr, **kwargs)","def eprint(*args, **kwargs):\n print(*args, file=sys.stderr, **kwargs)","def eprint(*args, **kwargs):\n print(*args, file=sys.stderr, **kwargs)","def eprint(*args, **kwargs):\n print(*args, file=sys.stderr, **kwargs)","def eprint(*args, **kwargs):\n print(*args, file=sys.stderr, **kwargs)","def eprint(*args, **kwargs):\n print(*args, file=sys.stderr, **kwargs)","def pprint_helper(self, angle, indent):\n # just here for defining the interface; work is done in subclasses\n pass","def _pprint(params, offset=0, printer=repr):\n # Do a multi-line justified repr:\n param_names = [p for p in params.keys() if p is not \"cost\"]\n param_names.sort()\n\n params_list = list()\n this_line_length = offset\n line_sep = ',\\n' + (1 + offset // 2) * ' '\n for i, name in enumerate(param_names):\n value = params[name]\n if isinstance(value, float):\n this_repr = '%s=%s' % (name, str(value))\n else:\n this_repr = '%s=%s' % (name, printer(value))\n if len(this_repr) > 500:\n this_repr = this_repr[:300] + '...' + this_repr[-100:]\n if i > 0:\n if (this_line_length + len(this_repr) >= 75 or '\\n' in this_repr):\n params_list.append(line_sep)\n this_line_length = len(line_sep)\n else:\n params_list.append(', ')\n this_line_length += 2\n params_list.append(this_repr)\n this_line_length += len(this_repr)\n # options = np.get_printoptions()\n # np.set_printoptions(**options)\n lines = ''.join(params_list)\n # Strip trailing space to avoid nightmare in doctests\n lines = '\\n'.join(l.rstrip(' ') for l in lines.split('\\n'))\n return lines","def init_printing(pretty_print=True, order=None, use_unicode=None):\n if pretty_print:\n stringify_func = lambda arg: pretty(arg, order=order, use_unicode=use_unicode)\n else:\n stringify_func = sstrrepr\n\n try:\n import IPython\n\n ip = IPython.ipapi.get()\n\n if ip is not None:\n def result_display(self, arg):\n \"\"\"IPython's pretty-printer display hook.\n\n This function was adapted from:\n\n ipython/IPython/hooks.py:155\n\n \"\"\"\n if self.rc.pprint:\n out = stringify_func(arg)\n\n if '\\n' in out:\n print\n\n print out\n else:\n print repr(arg)\n\n ip.set_hook('result_display', result_display)\n return\n except ImportError:\n pass\n\n import __builtin__, sys\n\n def displayhook(arg):\n \"\"\"Python's pretty-printer display hook.\n\n This function was adapted from:\n\n http://www.python.org/dev/peps/pep-0217/\n\n \"\"\"\n if arg is not None:\n __builtin__._ = None\n print stringify_func(arg)\n __builtin__._ = arg\n\n sys.displayhook = displayhook","def print_verbose(self) -> None:\n print(self)\n if self.meta is not None:\n print(self.meta.__repr__())","def _print(self, *args):\n return _ida_hexrays.cinsn_t__print(self, *args)","def my_print(self):\n if self.__size == 0:\n print(\"\")\n return\n [print(\"\") for x in range(0, self.__position[1])]\n for i in range(0, self.__size):\n [print(\" \", end=\"\") for i in range(0, self.__position[0])]\n [print(\"#\", end=\"\") for j in range(0, self.__size)]\n print(\"\")","def sequential_print_statements():\n pass","def print_post():\n print('| | |'),","def print_(*args, **kwargs):\r\n fp = kwargs.pop(\"file\", sys.stdout)\r\n if fp is None:\r\n return\r\n def write(data):\r\n if not isinstance(data, basestring):\r\n data = str(data)\r\n fp.write(data)\r\n want_unicode = False\r\n sep = kwargs.pop(\"sep\", None)\r\n if sep is not None:\r\n if isinstance(sep, unicode):\r\n want_unicode = True\r\n elif not isinstance(sep, str):\r\n raise TypeError(\"sep must be None or a string\")\r\n end = kwargs.pop(\"end\", None)\r\n if end is not None:\r\n if isinstance(end, unicode):\r\n want_unicode = True\r\n elif not isinstance(end, str):\r\n raise TypeError(\"end must be None or a string\")\r\n if kwargs:\r\n raise TypeError(\"invalid keyword arguments to print()\")\r\n if not want_unicode:\r\n for arg in args:\r\n if isinstance(arg, unicode):\r\n want_unicode = True\r\n break\r\n if want_unicode:\r\n newline = unicode(\"\\n\")\r\n space = unicode(\" \")\r\n else:\r\n newline = \"\\n\"\r\n space = \" \"\r\n if sep is None:\r\n sep = space\r\n if end is None:\r\n end = newline\r\n for i, arg in enumerate(args):\r\n if i:\r\n write(sep)\r\n write(arg)\r\n write(end)","def print_(*args, **kwargs):\r\n fp = kwargs.pop(\"file\", sys.stdout)\r\n if fp is None:\r\n return\r\n def write(data):\r\n if not isinstance(data, basestring):\r\n data = str(data)\r\n fp.write(data)\r\n want_unicode = False\r\n sep = kwargs.pop(\"sep\", None)\r\n if sep is not None:\r\n if isinstance(sep, unicode):\r\n want_unicode = True\r\n elif not isinstance(sep, str):\r\n raise TypeError(\"sep must be None or a string\")\r\n end = kwargs.pop(\"end\", None)\r\n if end is not None:\r\n if isinstance(end, unicode):\r\n want_unicode = True\r\n elif not isinstance(end, str):\r\n raise TypeError(\"end must be None or a string\")\r\n if kwargs:\r\n raise TypeError(\"invalid keyword arguments to print()\")\r\n if not want_unicode:\r\n for arg in args:\r\n if isinstance(arg, unicode):\r\n want_unicode = True\r\n break\r\n if want_unicode:\r\n newline = unicode(\"\\n\")\r\n space = unicode(\" \")\r\n else:\r\n newline = \"\\n\"\r\n space = \" \"\r\n if sep is None:\r\n sep = space\r\n if end is None:\r\n end = newline\r\n for i, arg in enumerate(args):\r\n if i:\r\n write(sep)\r\n write(arg)\r\n write(end)","def debugprint(r, prefix='', depth=-1, done=None, print_type=False,\r\n file=sys.stdout, print_destroy_map=False,\r\n print_view_map=False, order=None, ids='CHAR',\r\n stop_on_name=False, prefix_child=None):\r\n if depth == 0:\r\n return\r\n\r\n if order is None:\r\n order = []\r\n\r\n if done is None:\r\n done = dict()\r\n\r\n if print_type:\r\n type_str = ' <%s>' % r.type\r\n else:\r\n type_str = ''\r\n\r\n if prefix_child is None:\r\n prefix_child = prefix\r\n\r\n def get_id_str(obj):\r\n if obj in done:\r\n id_str = done[obj]\r\n elif ids == \"id\":\r\n id_str = \"[@%s]\" % str(id(r))\r\n elif ids == \"int\":\r\n id_str = \"[@%s]\" % str(len(done))\r\n elif ids == \"CHAR\":\r\n id_str = \"[@%s]\" % char_from_number(len(done))\r\n elif ids == \"\":\r\n id_str = \"\"\r\n done[obj] = id_str\r\n return id_str\r\n\r\n if hasattr(r.owner, 'op'):\r\n # this variable is the output of computation,\r\n # so just print out the apply\r\n a = r.owner\r\n\r\n r_name = getattr(r, 'name', '')\r\n # normally if the name isn't set, it'll be None, so\r\n # r_name is None here\r\n if r_name is None:\r\n r_name = ''\r\n\r\n if print_destroy_map:\r\n destroy_map_str = str(getattr(r.owner.op, 'destroy_map', ''))\r\n else:\r\n destroy_map_str = ''\r\n\r\n if print_view_map:\r\n view_map_str = str(getattr(r.owner.op, 'view_map', ''))\r\n else:\r\n view_map_str = ''\r\n if destroy_map_str and destroy_map_str != '{}':\r\n destroy_map_str = 'd=' + destroy_map_str\r\n if view_map_str and view_map_str != '{}':\r\n view_map_str = 'v=' + view_map_str\r\n\r\n o = ''\r\n if order:\r\n o = str(order.index(r.owner))\r\n already_printed = a in done # get_id_str put it in the dict\r\n id_str = get_id_str(a)\r\n\r\n if len(a.outputs) == 1:\r\n print >> file, '%s%s %s%s \\'%s\\' %s %s %s' % (prefix, a.op,\r\n id_str,\r\n type_str, r_name,\r\n destroy_map_str,\r\n view_map_str,\r\n o)\r\n else:\r\n print >> file, '%s%s.%i %s%s \\'%s\\' %s %s %s' % (prefix, a.op,\r\n a.outputs.index(r),\r\n id_str, type_str,\r\n r_name,\r\n destroy_map_str,\r\n view_map_str,\r\n o)\r\n if not already_printed:\r\n if (not stop_on_name or\r\n not (hasattr(r, 'name') and r.name is not None)):\r\n new_prefix = prefix_child + ' |'\r\n new_prefix_child = prefix_child + ' |'\r\n for idx, i in enumerate(a.inputs):\r\n if idx == len(a.inputs) - 1:\r\n new_prefix_child = prefix_child + ' '\r\n\r\n debugprint(i, new_prefix, depth=depth - 1, done=done,\r\n print_type=print_type, file=file, order=order,\r\n ids=ids, stop_on_name=stop_on_name,\r\n prefix_child=new_prefix_child)\r\n else:\r\n #this is an input variable\r\n id_str = get_id_str(r)\r\n print >> file, '%s%s %s%s' % (prefix, r, id_str, type_str)\r\n\r\n return file","def bpprint(self, out=None):\n if out is None:\n out = sys.stdout\n print(self.bpformat(), file=out)","def vprint(expr, **settings):\n\n outstr = vsprint(expr, **settings)\n\n import builtins\n if (outstr != 'None'):\n builtins._ = outstr\n print(outstr)","def _pprint(params, offset=0, printer=repr):\n # Do a multi-line justified repr:\n options = numpy.get_printoptions()\n numpy.set_printoptions(precision=5, threshold=64, edgeitems=2)\n params_list = list()\n this_line_length = offset\n line_sep = ',\\n' + (1 + offset // 2) * ' '\n for i, (k, v) in enumerate(sorted(params.items())):\n if isinstance(v, float):\n # use str for representing floating point numbers\n # this way we get consistent representation across\n # architectures and versions.\n this_repr = '%s=%s' % (k, str(v))\n else:\n # use repr of the rest\n this_repr = '%s=%s' % (k, printer(v))\n if len(this_repr) > 500:\n this_repr = this_repr[:300] + '...' + this_repr[-100:]\n if i > 0:\n if this_line_length + len(this_repr) >= 75 or '\\n' in this_repr:\n params_list.append(line_sep)\n this_line_length = len(line_sep)\n else:\n params_list.append(', ')\n this_line_length += 2\n params_list.append(this_repr)\n this_line_length += len(this_repr)\n\n numpy.set_printoptions(**options)\n lines = ''.join(params_list)\n # Strip trailing space to avoid nightmare in doctests\n lines = '\\n'.join(l.rstrip(' ') for l in lines.split('\\n'))\n return lines","def print_(*args, **kwargs):\n fp = kwargs.pop(\"file\", sys.stdout)\n if fp is None:\n return\n\n def write(data):\n if not isinstance(data, basestring):\n data = str(data)\n fp.write(data)\n want_unicode = False\n sep = kwargs.pop(\"sep\", None)\n if sep is not None:\n if isinstance(sep, unicode):\n want_unicode = True\n elif not isinstance(sep, str):\n raise TypeError(\"sep must be None or a string\")\n end = kwargs.pop(\"end\", None)\n if end is not None:\n if isinstance(end, unicode):\n want_unicode = True\n elif not isinstance(end, str):\n raise TypeError(\"end must be None or a string\")\n if kwargs:\n raise TypeError(\"invalid keyword arguments to print()\")\n if not want_unicode:\n for arg in args:\n if isinstance(arg, unicode):\n want_unicode = True\n break\n if want_unicode:\n newline = unicode(\"\\n\")\n space = unicode(\" \")\n else:\n newline = \"\\n\"\n space = \" \"\n if sep is None:\n sep = space\n if end is None:\n end = newline\n for i, arg in enumerate(args):\n if i:\n write(sep)\n write(arg)\n write(end)"],"string":"[\n \"def pprint(*args, **kwargs):\\n if PRINTING:\\n print(*args, **kwargs)\",\n \"def print_out():\\n pass\",\n \"def custom_print(*objects):\\n print(*objects, sep=OFS, end=ORS)\",\n \"def _print(self, *args):\\n return _ida_hexrays.vd_printer_t__print(self, *args)\",\n \"def _printable(self):\\n pass\",\n \"def _print_custom(self):\\n pass\",\n \"def pypprint(*args, **kwargs): # type: ignore\\n from typing import Iterable\\n\\n if len(args) != 1:\\n print(*args, **kwargs)\\n return\\n x = args[0]\\n if isinstance(x, dict):\\n for k, v in x.items():\\n print(f\\\"{k}:\\\", v, **kwargs)\\n elif isinstance(x, Iterable) and not isinstance(x, str):\\n for i in x:\\n print(i, **kwargs)\\n else:\\n print(x, **kwargs)\",\n \"def pprint(self):\\n # just here for defining the interface; work is done in subclasses\\n pass\",\n \"def print(*args, **kwargs):\\n with P_LOCK:\\n __builtins__.print(*args, **kwargs)\",\n \"def print(self):\\n # Your implementation here\",\n \"def p(value):\\n pp.pprint(value)\",\n \"def static_print(*args, __p=print, **kwargs):\\n __p(*args, **kwargs)\",\n \"def print(self, *args, **kwargs):\\n print(*args, **kwargs)\",\n \"def pprint(self):\\n print(self.pprint_str())\",\n \"def pprint(obj):\\n for argname in sorted([x for x in dir(obj) if not x.startswith('__')]):\\n # Skip callables\\n if hasattr(getattr(obj, argname), '__call__'):\\n continue\\n print(\\\"{} : {}\\\".format(argname, getattr(obj, argname)))\",\n \"def print_(self, s: str) -> None:\",\n \"def my_pprint(obj, intend = 0):\\n if isinstance(obj, dict):\\n for key, value in obj.items():\\n print(intend*\\\" \\\"+str(key)+\\\" : \\\")\\n my_pprint(value, intend = intend + 4)\\n print()\\n elif isinstance(obj, list):\\n for value in obj:\\n my_pprint(value, intend = intend + 4)\\n print()\\n elif isinstance(obj, bytes):\\n print(\\\"<binary data>\\\")\\n \\n else:\\n try:\\n print(intend*\\\" \\\"+str(obj))\\n except UnicodeDecodeError:\\n print(intend*\\\" \\\"\\\"<?>\\\")\",\n \"def test_print(chikin):\\n chikin.print()\",\n \"def _print(self, text):\\n\\t\\tif self.verbose:\\n\\t\\t\\tprint text\",\n \"def out(*args):\\r\\n print(*args)\",\n \"def __pprint(object, stream=None, indent=1, width=80, depth=None):\\n printer = PrettyPrinterExt(\\n stream=stream, indent=indent, width=width, depth=depth)\\n printer.pprint(object)\",\n \"def DumpPprint(data):\\n #NOTE(g): Import is done here, instead of the top of the file, to not require this module if it is not used\\n import pprint\\n \\n text = pprint.pformat(data)\\n \\n return text\",\n \"def repl_print_statements():\\n pass\",\n \"def test_03_pass_print(self):\\n print('Hello World!')\",\n \"def p(self):\\n self.printstdout = True\",\n \"def print(*args, **kwargs):\\n new_args = []\\n for arg in args:\\n if builtins.isinstance(arg, models.Point):\\n new_args.append(\\\"({0}, {1})\\\".format(arg.x, arg.y))\\n else:\\n new_args.append(arg)\\n\\n builtins.print(*new_args, **kwargs)\",\n \"def real_print(*args, **kwargs):\\n\\n kwargs.setdefault('file', real_stdout)\\n _python_print_function(*args, **kwargs)\",\n \"def to_print_out(self):\\n self.error_throw('output')\\n\\n if self.rank_method == methods_of_ranking[3]: #'diversified_ranking'\\n self.output_div('print')\\n else:\\n self.output('print')\",\n \"def debug_print(debug_data):\\n if DEBUG_MODE == \\\"true\\\":\\n pp.pprint(debug_data)\",\n \"def print(self):\\r\\n self.print_avec_separateur()\",\n \"def pprint(self):\\r\\n for i in self.items():\\r\\n print '%s => %r'%i\",\n \"def pprint(self, parameter_s=''):\\n ptformatter = self.shell.display_formatter.formatters['text/plain']\\n ptformatter.pprint = bool(1 - ptformatter.pprint)\\n print('Pretty printing has been turned',\\n ['OFF','ON'][ptformatter.pprint])\",\n \"def print(self):\\n print(self.pretty_str())\",\n \"def test_print4(self):\\n writer = StringIO()\\n collatz_print(writer, 1, 1, 1)\\n self.assertEqual(writer.getvalue(), \\\"1 1 1\\\\n\\\")\",\n \"def eprint(*args, **kwargs):\\n\\tprint(*args, file=sys.stderr, **kwargs)\",\n \"def _print(self, *args, **kwargs) -> None:\\n # Only print in verbose mode\\n if self._verbose:\\n arglist = list(args)\\n arglist[0] = f\\\"[buddy-{self._experiment_name}] {args[0]}\\\"\\n print(*arglist, **kwargs)\",\n \"def use_pypprint_for_implicit_print(self) -> None:\\n if self.implicit_print is not None:\\n self.implicit_print.func.id = \\\"pypprint\\\" # type: ignore\\n # Make sure we import it later\\n self.undefined.add(\\\"pypprint\\\")\",\n \"def test_print(self):\\n writer = StringIO()\\n collatz_print(writer, 1, 10, 20)\\n self.assertEqual(writer.getvalue(), \\\"1 10 20\\\\n\\\")\",\n \"def pprint(self):\\n return pformat(repr(self))\",\n \"def printer(message):\\n if VERBOSITY:\\n pprint(message)\",\n \"def rec_print(p):\\n if len(p) == 0:\\n return\\n t = p.pop(0)\\n print t\\n rec_print(p)\",\n \"def pformat(object):\\r\\n return PrettyPrinter().pformat(object)\",\n \"def printc(*a, **kw):\\n print(*a, **kw)\",\n \"def pr(x):\\n Card.print_pretty_cards(x)\",\n \"def debug_print(self, *content):\\n if self.debug:\\n print(*content)\",\n \"def pprint(object, stream=None):\\r\\n printer = PrettyPrinter(stream=stream)\\r\\n printer.pprint(object)\",\n \"def safe_print(*objs, errors=\\\"replace\\\"):\\n\\tprint(*(to_stdout(str(o), errors) for o in objs))\",\n \"def magic_Pprint(self, parameter_s=''):\\n \\n self.shell.outputcache.Pprint = 1 - self.shell.outputcache.Pprint\\n print 'Pretty printing has been turned', \\\\\\n ['OFF','ON'][self.shell.outputcache.Pprint]\",\n \"def print_output(tree):\\n print_value(tree)\\n print_tree(tree)\",\n \"def _Print(self, t):\\n self.RaiseError(t, \\\"Print not supported\\\")\",\n \"def vprint(*args, **kwargs ):\\n\\n forceprint = False\\n for key in kwargs:\\n if key == \\\"forceprint\\\":\\n forceprint =kwargs[key]\\n \\n line = ''\\n if debug or forceprint : \\n for arg in args:\\n line += str(arg) +\\\" \\\"\\n log = open(exepath + 'pyframe.log', 'a') \\n log.write(line + \\\"\\\\n\\\")\\n log.close() \\n print line\",\n \"def eprint(*pargs, **kargs):\\n print('\\\\u001b[31m', end='', file=sys.stderr)\\n print(*pargs, file=sys.stderr, **kargs)\\n print('\\\\u001b[0m', end='', file=sys.stderr)\",\n \"def printer(obj, ident=''):\\n import inspect\\n print ident + obj.__class__.__name__.upper()\\n ident += ' '\\n lists = []\\n for name in dir(obj):\\n elem = getattr(obj, name)\\n if isinstance(elem, list) and name != u'decoded_content':\\n lists.append(elem)\\n elif not inspect.ismethod(elem):\\n if not name.startswith('__'):\\n if name == u'data' and elem:\\n print ident + u'data = '\\n printer(elem, ident + ' ')\\n else:\\n print ident + u'%s\\\\t= %s' % (name, getattr(obj, name))\\n for l in lists:\\n for i in l:\\n printer(i, ident + ' ')\",\n \"def printer(obj, ident=''):\\n import inspect\\n print ident + obj.__class__.__name__.upper()\\n ident += ' '\\n lists = []\\n for name in dir(obj):\\n elem = getattr(obj, name)\\n if isinstance(elem, list) and name != u'decoded_content':\\n lists.append(elem)\\n elif not inspect.ismethod(elem):\\n if not name.startswith('__'):\\n if name == u'data' and elem:\\n print ident + u'data = '\\n printer(elem, ident + ' ')\\n else:\\n print ident + u'%s\\\\t= %s' % (name, getattr(obj, name))\\n for l in lists:\\n for i in l:\\n printer(i, ident + ' ')\",\n \"def _print(self, *args):\\n return _ida_hexrays.qstring_printer_t__print(self, *args)\",\n \"def pprint(self):\\n def pprintStr(node):\\n s = \\\"(\\\" + str(node.value) \\n for action in node.children:\\n s = s + \\\", \\\" + pprintStr(node.children[action])\\n s = s + \\\")\\\"\\n return s\\n\\n print pprintStr(self)\",\n \"def hook_print():\\n sys.stdout = PrintHook()\",\n \"def cmdPrint( self, *args):\\n return self.cmd( *args, **{ 'verbose': True } )\",\n \"def print_list(self):\\r\\n pass\",\n \"def debugprint(obj, depth=-1, print_type=False,\\r\\n file=None, ids='CHAR', stop_on_name=False):\\r\\n if file == 'str':\\r\\n _file = StringIO()\\r\\n elif file is None:\\r\\n _file = sys.stdout\\r\\n else:\\r\\n _file = file\\r\\n done = dict()\\r\\n results_to_print = []\\r\\n order = []\\r\\n if isinstance(obj, gof.Variable):\\r\\n results_to_print.append(obj)\\r\\n elif isinstance(obj, gof.Apply):\\r\\n results_to_print.extend(obj.outputs)\\r\\n elif isinstance(obj, Function):\\r\\n results_to_print.extend(obj.maker.fgraph.outputs)\\r\\n order = obj.maker.fgraph.toposort()\\r\\n elif isinstance(obj, (list, tuple)):\\r\\n results_to_print.extend(obj)\\r\\n elif isinstance(obj, gof.FunctionGraph):\\r\\n results_to_print.extend(obj.outputs)\\r\\n order = obj.toposort()\\r\\n elif isinstance(obj, (int, long, float, numpy.ndarray)):\\r\\n print obj\\r\\n else:\\r\\n raise TypeError(\\\"debugprint cannot print an object of this type\\\", obj)\\r\\n for r in results_to_print:\\r\\n debugmode.debugprint(r, depth=depth, done=done, print_type=print_type,\\r\\n file=_file, order=order, ids=ids,\\r\\n stop_on_name=stop_on_name)\\r\\n if file is _file:\\r\\n return file\\r\\n elif file == 'str':\\r\\n return _file.getvalue()\\r\\n else:\\r\\n _file.flush()\",\n \"def _get_print_fn(file=sys.stdout):\\n def _print_fn(op, xin,):\\n for attr in op.attrs:\\n temp = getattr(xin, attr)\\n if callable(temp):\\n pmsg = temp()\\n else:\\n pmsg = temp\\n print(op.message, attr, '=', pmsg, file=file)\\n return _print_fn\",\n \"def test_print1(self):\\n writer = StringIO()\\n collatz_print(writer, 100, 200, 125)\\n self.assertEqual(writer.getvalue(), \\\"100 200 125\\\\n\\\")\",\n \"def printOutput(self):\\n pass\",\n \"def _print(self, *args):\\n return _ida_hexrays.cnumber_t__print(self, *args)\",\n \"def setPrint():\\n (e,d,sr,sw) = codecs.lookup('utf-8')\\n unicode_to_utf8 = sw(sys.stdout)\\n sys.stdout = unicode_to_utf8\",\n \"def pr(string, verbose):\\n if(verbose):\\n print(string)\",\n \"def print(*args, sep=\\\" \\\"):\\n pass\",\n \"def printv(self, *arg):\\n if self.verbose:\\n print(*arg)\",\n \"def print(self):\\n\\n print(self)\",\n \"def _p(self, *args, level=2, **kwargs):\\n if self._verbosity >= level:\\n print(*args, **kwargs)\",\n \"def test_print2(self):\\n writer = StringIO()\\n collatz_print(writer, 201, 210, 89)\\n self.assertEqual(writer.getvalue(), \\\"201 210 89\\\\n\\\")\",\n \"def print_pointers(self):\\n\\n ### FILL IN ###\",\n \"def foo_printer(self):\\n print(\\\"\\\\nHi I'm {}\\\".format(self.foo))\",\n \"def printed(method):\\n\\t\\tdef wrapper(cls, *args):\\n\\t\\t\\tif cls.verbose:\\n\\t\\t\\t\\treturn method(cls, *args)\\n\\t\\treturn wrapper\",\n \"def print_me(self, tabs=0, tab=' '):\\n pre = tab*tabs\\n print(pre+'Producer:')\\n print(pre+' produces:', self._produces)\\n print(pre+' consumes:', self._consumes)\\n print(pre+' transfer:', self._transfer)\\n print(pre+' capacity:', self._capacity)\",\n \"def _print(cls, quad):\\n\\t\\tprint(\\\"\\\\nLIGHT OUTPUT:\\\\n<<<<{}>>>>\\\".format(ast.literal_eval(str(cls.get_address_value(quad.result)))))\\n\\t\\tprint(\\\"END\\\")\\n\\n\\t\\tvar = cls.get_address_value(quad.result)\\n\\t\\tif isinstance(var, collections.Iterable):\\n\\t\\t\\tprint(\\\"DEEP COPY\\\")\\n\\t\\t\\tcls.print_queue.enqueue(copy.deepcopy(var))\\n\\t\\telse:\\n\\t\\t\\tcls.print_queue.enqueue(var)\",\n \"def printout(*args, **kwargs):\\n console_print(sys.stdout, *args, **kwargs)\",\n \"def pprint(x):\\n if is_theano_object(x):\\n return _gettheano().printing.pprint(x)\\n else:\\n return str(x)\",\n \"def PrettyPrint(self):\\r\\n print(self.data)\\r\\n return\",\n \"def print(self):\\n self.print_avec_separateur(\\\" \\\")\",\n \"def eprint(*args, **kwargs):\\n print(*args, file=sys.stderr, **kwargs)\",\n \"def eprint(*args, **kwargs):\\n print(*args, file=sys.stderr, **kwargs)\",\n \"def eprint(*args, **kwargs):\\n print(*args, file=sys.stderr, **kwargs)\",\n \"def eprint(*args, **kwargs):\\n print(*args, file=sys.stderr, **kwargs)\",\n \"def eprint(*args, **kwargs):\\n print(*args, file=sys.stderr, **kwargs)\",\n \"def eprint(*args, **kwargs):\\n print(*args, file=sys.stderr, **kwargs)\",\n \"def pprint_helper(self, angle, indent):\\n # just here for defining the interface; work is done in subclasses\\n pass\",\n \"def _pprint(params, offset=0, printer=repr):\\n # Do a multi-line justified repr:\\n param_names = [p for p in params.keys() if p is not \\\"cost\\\"]\\n param_names.sort()\\n\\n params_list = list()\\n this_line_length = offset\\n line_sep = ',\\\\n' + (1 + offset // 2) * ' '\\n for i, name in enumerate(param_names):\\n value = params[name]\\n if isinstance(value, float):\\n this_repr = '%s=%s' % (name, str(value))\\n else:\\n this_repr = '%s=%s' % (name, printer(value))\\n if len(this_repr) > 500:\\n this_repr = this_repr[:300] + '...' + this_repr[-100:]\\n if i > 0:\\n if (this_line_length + len(this_repr) >= 75 or '\\\\n' in this_repr):\\n params_list.append(line_sep)\\n this_line_length = len(line_sep)\\n else:\\n params_list.append(', ')\\n this_line_length += 2\\n params_list.append(this_repr)\\n this_line_length += len(this_repr)\\n # options = np.get_printoptions()\\n # np.set_printoptions(**options)\\n lines = ''.join(params_list)\\n # Strip trailing space to avoid nightmare in doctests\\n lines = '\\\\n'.join(l.rstrip(' ') for l in lines.split('\\\\n'))\\n return lines\",\n \"def init_printing(pretty_print=True, order=None, use_unicode=None):\\n if pretty_print:\\n stringify_func = lambda arg: pretty(arg, order=order, use_unicode=use_unicode)\\n else:\\n stringify_func = sstrrepr\\n\\n try:\\n import IPython\\n\\n ip = IPython.ipapi.get()\\n\\n if ip is not None:\\n def result_display(self, arg):\\n \\\"\\\"\\\"IPython's pretty-printer display hook.\\n\\n This function was adapted from:\\n\\n ipython/IPython/hooks.py:155\\n\\n \\\"\\\"\\\"\\n if self.rc.pprint:\\n out = stringify_func(arg)\\n\\n if '\\\\n' in out:\\n print\\n\\n print out\\n else:\\n print repr(arg)\\n\\n ip.set_hook('result_display', result_display)\\n return\\n except ImportError:\\n pass\\n\\n import __builtin__, sys\\n\\n def displayhook(arg):\\n \\\"\\\"\\\"Python's pretty-printer display hook.\\n\\n This function was adapted from:\\n\\n http://www.python.org/dev/peps/pep-0217/\\n\\n \\\"\\\"\\\"\\n if arg is not None:\\n __builtin__._ = None\\n print stringify_func(arg)\\n __builtin__._ = arg\\n\\n sys.displayhook = displayhook\",\n \"def print_verbose(self) -> None:\\n print(self)\\n if self.meta is not None:\\n print(self.meta.__repr__())\",\n \"def _print(self, *args):\\n return _ida_hexrays.cinsn_t__print(self, *args)\",\n \"def my_print(self):\\n if self.__size == 0:\\n print(\\\"\\\")\\n return\\n [print(\\\"\\\") for x in range(0, self.__position[1])]\\n for i in range(0, self.__size):\\n [print(\\\" \\\", end=\\\"\\\") for i in range(0, self.__position[0])]\\n [print(\\\"#\\\", end=\\\"\\\") for j in range(0, self.__size)]\\n print(\\\"\\\")\",\n \"def sequential_print_statements():\\n pass\",\n \"def print_post():\\n print('| | |'),\",\n \"def print_(*args, **kwargs):\\r\\n fp = kwargs.pop(\\\"file\\\", sys.stdout)\\r\\n if fp is None:\\r\\n return\\r\\n def write(data):\\r\\n if not isinstance(data, basestring):\\r\\n data = str(data)\\r\\n fp.write(data)\\r\\n want_unicode = False\\r\\n sep = kwargs.pop(\\\"sep\\\", None)\\r\\n if sep is not None:\\r\\n if isinstance(sep, unicode):\\r\\n want_unicode = True\\r\\n elif not isinstance(sep, str):\\r\\n raise TypeError(\\\"sep must be None or a string\\\")\\r\\n end = kwargs.pop(\\\"end\\\", None)\\r\\n if end is not None:\\r\\n if isinstance(end, unicode):\\r\\n want_unicode = True\\r\\n elif not isinstance(end, str):\\r\\n raise TypeError(\\\"end must be None or a string\\\")\\r\\n if kwargs:\\r\\n raise TypeError(\\\"invalid keyword arguments to print()\\\")\\r\\n if not want_unicode:\\r\\n for arg in args:\\r\\n if isinstance(arg, unicode):\\r\\n want_unicode = True\\r\\n break\\r\\n if want_unicode:\\r\\n newline = unicode(\\\"\\\\n\\\")\\r\\n space = unicode(\\\" \\\")\\r\\n else:\\r\\n newline = \\\"\\\\n\\\"\\r\\n space = \\\" \\\"\\r\\n if sep is None:\\r\\n sep = space\\r\\n if end is None:\\r\\n end = newline\\r\\n for i, arg in enumerate(args):\\r\\n if i:\\r\\n write(sep)\\r\\n write(arg)\\r\\n write(end)\",\n \"def print_(*args, **kwargs):\\r\\n fp = kwargs.pop(\\\"file\\\", sys.stdout)\\r\\n if fp is None:\\r\\n return\\r\\n def write(data):\\r\\n if not isinstance(data, basestring):\\r\\n data = str(data)\\r\\n fp.write(data)\\r\\n want_unicode = False\\r\\n sep = kwargs.pop(\\\"sep\\\", None)\\r\\n if sep is not None:\\r\\n if isinstance(sep, unicode):\\r\\n want_unicode = True\\r\\n elif not isinstance(sep, str):\\r\\n raise TypeError(\\\"sep must be None or a string\\\")\\r\\n end = kwargs.pop(\\\"end\\\", None)\\r\\n if end is not None:\\r\\n if isinstance(end, unicode):\\r\\n want_unicode = True\\r\\n elif not isinstance(end, str):\\r\\n raise TypeError(\\\"end must be None or a string\\\")\\r\\n if kwargs:\\r\\n raise TypeError(\\\"invalid keyword arguments to print()\\\")\\r\\n if not want_unicode:\\r\\n for arg in args:\\r\\n if isinstance(arg, unicode):\\r\\n want_unicode = True\\r\\n break\\r\\n if want_unicode:\\r\\n newline = unicode(\\\"\\\\n\\\")\\r\\n space = unicode(\\\" \\\")\\r\\n else:\\r\\n newline = \\\"\\\\n\\\"\\r\\n space = \\\" \\\"\\r\\n if sep is None:\\r\\n sep = space\\r\\n if end is None:\\r\\n end = newline\\r\\n for i, arg in enumerate(args):\\r\\n if i:\\r\\n write(sep)\\r\\n write(arg)\\r\\n write(end)\",\n \"def debugprint(r, prefix='', depth=-1, done=None, print_type=False,\\r\\n file=sys.stdout, print_destroy_map=False,\\r\\n print_view_map=False, order=None, ids='CHAR',\\r\\n stop_on_name=False, prefix_child=None):\\r\\n if depth == 0:\\r\\n return\\r\\n\\r\\n if order is None:\\r\\n order = []\\r\\n\\r\\n if done is None:\\r\\n done = dict()\\r\\n\\r\\n if print_type:\\r\\n type_str = ' <%s>' % r.type\\r\\n else:\\r\\n type_str = ''\\r\\n\\r\\n if prefix_child is None:\\r\\n prefix_child = prefix\\r\\n\\r\\n def get_id_str(obj):\\r\\n if obj in done:\\r\\n id_str = done[obj]\\r\\n elif ids == \\\"id\\\":\\r\\n id_str = \\\"[@%s]\\\" % str(id(r))\\r\\n elif ids == \\\"int\\\":\\r\\n id_str = \\\"[@%s]\\\" % str(len(done))\\r\\n elif ids == \\\"CHAR\\\":\\r\\n id_str = \\\"[@%s]\\\" % char_from_number(len(done))\\r\\n elif ids == \\\"\\\":\\r\\n id_str = \\\"\\\"\\r\\n done[obj] = id_str\\r\\n return id_str\\r\\n\\r\\n if hasattr(r.owner, 'op'):\\r\\n # this variable is the output of computation,\\r\\n # so just print out the apply\\r\\n a = r.owner\\r\\n\\r\\n r_name = getattr(r, 'name', '')\\r\\n # normally if the name isn't set, it'll be None, so\\r\\n # r_name is None here\\r\\n if r_name is None:\\r\\n r_name = ''\\r\\n\\r\\n if print_destroy_map:\\r\\n destroy_map_str = str(getattr(r.owner.op, 'destroy_map', ''))\\r\\n else:\\r\\n destroy_map_str = ''\\r\\n\\r\\n if print_view_map:\\r\\n view_map_str = str(getattr(r.owner.op, 'view_map', ''))\\r\\n else:\\r\\n view_map_str = ''\\r\\n if destroy_map_str and destroy_map_str != '{}':\\r\\n destroy_map_str = 'd=' + destroy_map_str\\r\\n if view_map_str and view_map_str != '{}':\\r\\n view_map_str = 'v=' + view_map_str\\r\\n\\r\\n o = ''\\r\\n if order:\\r\\n o = str(order.index(r.owner))\\r\\n already_printed = a in done # get_id_str put it in the dict\\r\\n id_str = get_id_str(a)\\r\\n\\r\\n if len(a.outputs) == 1:\\r\\n print >> file, '%s%s %s%s \\\\'%s\\\\' %s %s %s' % (prefix, a.op,\\r\\n id_str,\\r\\n type_str, r_name,\\r\\n destroy_map_str,\\r\\n view_map_str,\\r\\n o)\\r\\n else:\\r\\n print >> file, '%s%s.%i %s%s \\\\'%s\\\\' %s %s %s' % (prefix, a.op,\\r\\n a.outputs.index(r),\\r\\n id_str, type_str,\\r\\n r_name,\\r\\n destroy_map_str,\\r\\n view_map_str,\\r\\n o)\\r\\n if not already_printed:\\r\\n if (not stop_on_name or\\r\\n not (hasattr(r, 'name') and r.name is not None)):\\r\\n new_prefix = prefix_child + ' |'\\r\\n new_prefix_child = prefix_child + ' |'\\r\\n for idx, i in enumerate(a.inputs):\\r\\n if idx == len(a.inputs) - 1:\\r\\n new_prefix_child = prefix_child + ' '\\r\\n\\r\\n debugprint(i, new_prefix, depth=depth - 1, done=done,\\r\\n print_type=print_type, file=file, order=order,\\r\\n ids=ids, stop_on_name=stop_on_name,\\r\\n prefix_child=new_prefix_child)\\r\\n else:\\r\\n #this is an input variable\\r\\n id_str = get_id_str(r)\\r\\n print >> file, '%s%s %s%s' % (prefix, r, id_str, type_str)\\r\\n\\r\\n return file\",\n \"def bpprint(self, out=None):\\n if out is None:\\n out = sys.stdout\\n print(self.bpformat(), file=out)\",\n \"def vprint(expr, **settings):\\n\\n outstr = vsprint(expr, **settings)\\n\\n import builtins\\n if (outstr != 'None'):\\n builtins._ = outstr\\n print(outstr)\",\n \"def _pprint(params, offset=0, printer=repr):\\n # Do a multi-line justified repr:\\n options = numpy.get_printoptions()\\n numpy.set_printoptions(precision=5, threshold=64, edgeitems=2)\\n params_list = list()\\n this_line_length = offset\\n line_sep = ',\\\\n' + (1 + offset // 2) * ' '\\n for i, (k, v) in enumerate(sorted(params.items())):\\n if isinstance(v, float):\\n # use str for representing floating point numbers\\n # this way we get consistent representation across\\n # architectures and versions.\\n this_repr = '%s=%s' % (k, str(v))\\n else:\\n # use repr of the rest\\n this_repr = '%s=%s' % (k, printer(v))\\n if len(this_repr) > 500:\\n this_repr = this_repr[:300] + '...' + this_repr[-100:]\\n if i > 0:\\n if this_line_length + len(this_repr) >= 75 or '\\\\n' in this_repr:\\n params_list.append(line_sep)\\n this_line_length = len(line_sep)\\n else:\\n params_list.append(', ')\\n this_line_length += 2\\n params_list.append(this_repr)\\n this_line_length += len(this_repr)\\n\\n numpy.set_printoptions(**options)\\n lines = ''.join(params_list)\\n # Strip trailing space to avoid nightmare in doctests\\n lines = '\\\\n'.join(l.rstrip(' ') for l in lines.split('\\\\n'))\\n return lines\",\n \"def print_(*args, **kwargs):\\n fp = kwargs.pop(\\\"file\\\", sys.stdout)\\n if fp is None:\\n return\\n\\n def write(data):\\n if not isinstance(data, basestring):\\n data = str(data)\\n fp.write(data)\\n want_unicode = False\\n sep = kwargs.pop(\\\"sep\\\", None)\\n if sep is not None:\\n if isinstance(sep, unicode):\\n want_unicode = True\\n elif not isinstance(sep, str):\\n raise TypeError(\\\"sep must be None or a string\\\")\\n end = kwargs.pop(\\\"end\\\", None)\\n if end is not None:\\n if isinstance(end, unicode):\\n want_unicode = True\\n elif not isinstance(end, str):\\n raise TypeError(\\\"end must be None or a string\\\")\\n if kwargs:\\n raise TypeError(\\\"invalid keyword arguments to print()\\\")\\n if not want_unicode:\\n for arg in args:\\n if isinstance(arg, unicode):\\n want_unicode = True\\n break\\n if want_unicode:\\n newline = unicode(\\\"\\\\n\\\")\\n space = unicode(\\\" \\\")\\n else:\\n newline = \\\"\\\\n\\\"\\n space = \\\" \\\"\\n if sep is None:\\n sep = space\\n if end is None:\\n end = newline\\n for i, arg in enumerate(args):\\n if i:\\n write(sep)\\n write(arg)\\n write(end)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75577617","0.73375154","0.6986672","0.698475","0.6944995","0.692333","0.6899106","0.6898902","0.68146646","0.6806209","0.6753795","0.67497987","0.6744008","0.6700308","0.6691256","0.6674591","0.6658083","0.66091245","0.6606931","0.6601862","0.6563738","0.6561717","0.65549695","0.6494838","0.6473391","0.64491546","0.6411177","0.6340302","0.6339321","0.6335031","0.6332035","0.6315847","0.631272","0.6297732","0.62969106","0.6283717","0.6279154","0.6271603","0.62673396","0.6265511","0.62629336","0.6258366","0.6258278","0.62501305","0.6248315","0.62459755","0.6244254","0.6242083","0.62393075","0.62156516","0.6208198","0.62068796","0.62062824","0.62062824","0.6194123","0.6189738","0.6183852","0.6183035","0.61697906","0.61614454","0.6160741","0.61544997","0.61528033","0.6150831","0.6147288","0.61380607","0.613793","0.61300766","0.61278135","0.6125416","0.6114217","0.61126333","0.6100682","0.60998785","0.6096818","0.6081694","0.6076982","0.6072701","0.6060028","0.60581726","0.6055044","0.6055044","0.6055044","0.6055044","0.6055044","0.6055044","0.6043662","0.6037599","0.60336643","0.6030174","0.60290223","0.60242903","0.6016989","0.6004274","0.60005474","0.60005474","0.60003483","0.599558","0.59923434","0.5979316","0.59777945"],"string":"[\n \"0.75577617\",\n \"0.73375154\",\n \"0.6986672\",\n \"0.698475\",\n \"0.6944995\",\n \"0.692333\",\n \"0.6899106\",\n \"0.6898902\",\n \"0.68146646\",\n \"0.6806209\",\n \"0.6753795\",\n \"0.67497987\",\n \"0.6744008\",\n \"0.6700308\",\n \"0.6691256\",\n \"0.6674591\",\n \"0.6658083\",\n \"0.66091245\",\n \"0.6606931\",\n \"0.6601862\",\n \"0.6563738\",\n \"0.6561717\",\n \"0.65549695\",\n \"0.6494838\",\n \"0.6473391\",\n \"0.64491546\",\n \"0.6411177\",\n \"0.6340302\",\n \"0.6339321\",\n \"0.6335031\",\n \"0.6332035\",\n \"0.6315847\",\n \"0.631272\",\n \"0.6297732\",\n \"0.62969106\",\n \"0.6283717\",\n \"0.6279154\",\n \"0.6271603\",\n \"0.62673396\",\n \"0.6265511\",\n \"0.62629336\",\n \"0.6258366\",\n \"0.6258278\",\n \"0.62501305\",\n \"0.6248315\",\n \"0.62459755\",\n \"0.6244254\",\n \"0.6242083\",\n \"0.62393075\",\n \"0.62156516\",\n \"0.6208198\",\n \"0.62068796\",\n \"0.62062824\",\n \"0.62062824\",\n \"0.6194123\",\n \"0.6189738\",\n \"0.6183852\",\n \"0.6183035\",\n \"0.61697906\",\n \"0.61614454\",\n \"0.6160741\",\n \"0.61544997\",\n \"0.61528033\",\n \"0.6150831\",\n \"0.6147288\",\n \"0.61380607\",\n \"0.613793\",\n \"0.61300766\",\n \"0.61278135\",\n \"0.6125416\",\n \"0.6114217\",\n \"0.61126333\",\n \"0.6100682\",\n \"0.60998785\",\n \"0.6096818\",\n \"0.6081694\",\n \"0.6076982\",\n \"0.6072701\",\n \"0.6060028\",\n \"0.60581726\",\n \"0.6055044\",\n \"0.6055044\",\n \"0.6055044\",\n \"0.6055044\",\n \"0.6055044\",\n \"0.6055044\",\n \"0.6043662\",\n \"0.6037599\",\n \"0.60336643\",\n \"0.6030174\",\n \"0.60290223\",\n \"0.60242903\",\n \"0.6016989\",\n \"0.6004274\",\n \"0.60005474\",\n \"0.60005474\",\n \"0.60003483\",\n \"0.599558\",\n \"0.59923434\",\n \"0.5979316\",\n \"0.59777945\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24579,"cells":{"query":{"kind":"string","value":"Returns true if both objects are equal"},"document":{"kind":"string","value":"def __eq__(self, other):\n if not isinstance(other, TypesConsoleCertificateSettings):\n return False\n\n return self.to_dict() == other.to_dict()"},"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 __eq__(self, other):\n return are_equal(self, other)","def __eq__(self, other):\n return are_equal(self, other)","def __eq__(self,other):\n try: return self.object==other.object and isinstance(self,type(other))\n except: return False","def __eq__(self, other):\n if isinstance(self, other.__class__):\n return self.__dict__ == other.__dict__\n return False","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n if isinstance(other, self.__class__):\n return self.__dict__ == other.__dict__\n return False","def __eq__(self, other):\n if isinstance(other, self.__class__):\n return self.__dict__ == other.__dict__\n return False","def __eq__(self, other):\r\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n # Ensure same class and values match\n if isinstance(other, self.__class__):\n return self.__dict__ == other.__dict__\n else:\n return False","def is_equal(self, a, b):\n return a is b","def is_equal(self, a, b):\n return a == b","def __eq__(self, other):\n return self is other","def __eq__(self, other):\n return self is other","def __eq__(self, other):\r\n if isinstance(other, self.__class__):\r\n return self.__dict__ == other.__dict__\r\n else:\r\n return False","def is_equal(o1: object, o2: object) -> bool:\n if o1 is None and o2 is None:\n return True\n if o1 is None:\n return False\n return o1 == o2","def __eq__(self,other):\n return self is other","def is_equal(self, a, b):\n return a.X[0] == b.X[0]","def __eq__(self, other):\n return type(self) == type(other) and self.id == other.id","def __eq__(self, other) -> bool:\n if json.dumps(self.data,sort_keys=True) == json.dumps(other.data,sort_keys=True):\n return True\n else:\n return False","def __eq__(self, other):\n if not isinstance(other, Single2HaObject):\n return False\n\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other","def __eq__(self, other):\n if isinstance(other, self.__class__):\n return self.__hash__() == other.__hash__()\n return False","def __eq__(self, other):\n if self.__class__ != other.__class__:\n return False\n if self.primary != other.primary:\n return False\n return True","def __eq__(self, other) -> bool:\n if other is None:\n return False\n return self.__hash__() == other.__hash__()","def __eq__(self, other):\n if not isinstance(other, ObjectInfo):\n return False\n\n return self.__dict__ == other.__dict__","def __eq__(self: _TT, other: object) -> bool:\n return self.eq(other) # type: ignore","def __eq__(self, other):\n return id(self) == id(other)","def __eq__(self, other) -> bool:\n return type(self) == type(other) and \\\n self._id == other.id and \\\n self.code == other.code and \\\n self.name == other.name and \\\n self.gender == other.gender and \\\n self.date_of_birth == other.date_of_birth","def equals(self, other): # -> bool:\n ...","def equals(self, obj: object) -> bool:\n ...","def __eq__(self, other):\n for attr in self._attrs_to_save:\n try:\n if getattr(self, attr) != getattr(other, attr):\n return False\n except AttributeError:\n return False\n return True","def __eq__(self, other):\n if type(other) is type(self):\n return (self.x == other.x and self.y == other.y and self.z == other.z)\n return False","def __eq__(self, other):\n if isinstance(other, self.__class__):\n return self.x == other.x and self.y == other.y\n return False","def __eq__(self, other: object) -> bool:\n if not isinstance(other, self.__class__):\n return NotImplemented\n\n return (\n self.name,\n self.submit_at,\n self.subreddit,\n self.title,\n self.body_template,\n ) == (\n other.name,\n other.submit_at,\n other.subreddit,\n other.title,\n other.body_template,\n )","def __eq__(self, other):\n # Check that we share the same class as this object\n if not isinstance(other, type(self)):\n return False\n\n return hash(self) == hash(other)","def __eq__(self, other):\n if not isinstance(other, PreviewObjectAutofill):\n return False\n\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return equal(self, other)","def __eq__(self, other: Any) -> bool:\n return self.__class__ is other.__class__ and self.identifier == other.identifier","def __eq__(self, other):\n return self.__id == other.get_id()","def __eq__ (self, other):\n if type(self) == type(other):\n return self._m == other._m\n else:\n return False","def __eq__(self, other):\n if not isinstance(other, Referent):\n return False\n\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.properties == other.properties","def __eq__(self, other):\n return self.items() == other.items()","def __eq__(self, other):\n return hash(self) == hash(other)","def __eq__(self, other):\n return hash(self) == hash(other)","def __eq__(self, other):\n return hash(self) == hash(other)","def __eq__(self, other):\n return self.x == other.x and self.y == other.y","def __eq__(self, other):\n\n if self is other:\n return True\n return hash(self) == hash(other)","def __eq__(self, other):\n if other._field1 == self._field1:\n return True\n return False","def same_as(self, other):\n return super().__eq__(other)","def __eq__(self, other):\n try:\n return other and \\\n self.id == other.id\n\n except AttributeError:\n return False","def __eq__(self, other):\r\n\t\treturn self._to_pylist() == other._to_pylist()","def __eq__(self, other):\n if not isinstance(other, Fiddle):\n return False\n\n return self.__dict__ == other.__dict__"],"string":"[\n \"def __eq__(self, other):\\n return are_equal(self, other)\",\n \"def __eq__(self, other):\\n return are_equal(self, other)\",\n \"def __eq__(self,other):\\n try: return self.object==other.object and isinstance(self,type(other))\\n except: return False\",\n \"def __eq__(self, other):\\n if isinstance(self, other.__class__):\\n return self.__dict__ == other.__dict__\\n return False\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n if isinstance(other, self.__class__):\\n return self.__dict__ == other.__dict__\\n return False\",\n \"def __eq__(self, other):\\n if isinstance(other, self.__class__):\\n return self.__dict__ == other.__dict__\\n return False\",\n \"def __eq__(self, other):\\r\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n # Ensure same class and values match\\n if isinstance(other, self.__class__):\\n return self.__dict__ == other.__dict__\\n else:\\n return False\",\n \"def is_equal(self, a, b):\\n return a is b\",\n \"def is_equal(self, a, b):\\n return a == b\",\n \"def __eq__(self, other):\\n return self is other\",\n \"def __eq__(self, other):\\n return self is other\",\n \"def __eq__(self, other):\\r\\n if isinstance(other, self.__class__):\\r\\n return self.__dict__ == other.__dict__\\r\\n else:\\r\\n return False\",\n \"def is_equal(o1: object, o2: object) -> bool:\\n if o1 is None and o2 is None:\\n return True\\n if o1 is None:\\n return False\\n return o1 == o2\",\n \"def __eq__(self,other):\\n return self is other\",\n \"def is_equal(self, a, b):\\n return a.X[0] == b.X[0]\",\n \"def __eq__(self, other):\\n return type(self) == type(other) and self.id == other.id\",\n \"def __eq__(self, other) -> bool:\\n if json.dumps(self.data,sort_keys=True) == json.dumps(other.data,sort_keys=True):\\n return True\\n else:\\n return False\",\n \"def __eq__(self, other):\\n if not isinstance(other, Single2HaObject):\\n return False\\n\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other\",\n \"def __eq__(self, other):\\n if isinstance(other, self.__class__):\\n return self.__hash__() == other.__hash__()\\n return False\",\n \"def __eq__(self, other):\\n if self.__class__ != other.__class__:\\n return False\\n if self.primary != other.primary:\\n return False\\n return True\",\n \"def __eq__(self, other) -> bool:\\n if other is None:\\n return False\\n return self.__hash__() == other.__hash__()\",\n \"def __eq__(self, other):\\n if not isinstance(other, ObjectInfo):\\n return False\\n\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self: _TT, other: object) -> bool:\\n return self.eq(other) # type: ignore\",\n \"def __eq__(self, other):\\n return id(self) == id(other)\",\n \"def __eq__(self, other) -> bool:\\n return type(self) == type(other) and \\\\\\n self._id == other.id and \\\\\\n self.code == other.code and \\\\\\n self.name == other.name and \\\\\\n self.gender == other.gender and \\\\\\n self.date_of_birth == other.date_of_birth\",\n \"def equals(self, other): # -> bool:\\n ...\",\n \"def equals(self, obj: object) -> bool:\\n ...\",\n \"def __eq__(self, other):\\n for attr in self._attrs_to_save:\\n try:\\n if getattr(self, attr) != getattr(other, attr):\\n return False\\n except AttributeError:\\n return False\\n return True\",\n \"def __eq__(self, other):\\n if type(other) is type(self):\\n return (self.x == other.x and self.y == other.y and self.z == other.z)\\n return False\",\n \"def __eq__(self, other):\\n if isinstance(other, self.__class__):\\n return self.x == other.x and self.y == other.y\\n return False\",\n \"def __eq__(self, other: object) -> bool:\\n if not isinstance(other, self.__class__):\\n return NotImplemented\\n\\n return (\\n self.name,\\n self.submit_at,\\n self.subreddit,\\n self.title,\\n self.body_template,\\n ) == (\\n other.name,\\n other.submit_at,\\n other.subreddit,\\n other.title,\\n other.body_template,\\n )\",\n \"def __eq__(self, other):\\n # Check that we share the same class as this object\\n if not isinstance(other, type(self)):\\n return False\\n\\n return hash(self) == hash(other)\",\n \"def __eq__(self, other):\\n if not isinstance(other, PreviewObjectAutofill):\\n return False\\n\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return equal(self, other)\",\n \"def __eq__(self, other: Any) -> bool:\\n return self.__class__ is other.__class__ and self.identifier == other.identifier\",\n \"def __eq__(self, other):\\n return self.__id == other.get_id()\",\n \"def __eq__ (self, other):\\n if type(self) == type(other):\\n return self._m == other._m\\n else:\\n return False\",\n \"def __eq__(self, other):\\n if not isinstance(other, Referent):\\n return False\\n\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.properties == other.properties\",\n \"def __eq__(self, other):\\n return self.items() == other.items()\",\n \"def __eq__(self, other):\\n return hash(self) == hash(other)\",\n \"def __eq__(self, other):\\n return hash(self) == hash(other)\",\n \"def __eq__(self, other):\\n return hash(self) == hash(other)\",\n \"def __eq__(self, other):\\n return self.x == other.x and self.y == other.y\",\n \"def __eq__(self, other):\\n\\n if self is other:\\n return True\\n return hash(self) == hash(other)\",\n \"def __eq__(self, other):\\n if other._field1 == self._field1:\\n return True\\n return False\",\n \"def same_as(self, other):\\n return super().__eq__(other)\",\n \"def __eq__(self, other):\\n try:\\n return other and \\\\\\n self.id == other.id\\n\\n except AttributeError:\\n return False\",\n \"def __eq__(self, other):\\r\\n\\t\\treturn self._to_pylist() == other._to_pylist()\",\n \"def __eq__(self, other):\\n if not isinstance(other, Fiddle):\\n return False\\n\\n return self.__dict__ == other.__dict__\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8088132","0.8088132","0.8054589","0.7982687","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.7961088","0.7961088","0.79433626","0.79303336","0.7926563","0.7897525","0.78826123","0.78826123","0.78806067","0.7872423","0.7868354","0.78668815","0.7825702","0.7819993","0.78162885","0.78078854","0.78068274","0.7796298","0.7794721","0.7784825","0.77790844","0.7769397","0.77534705","0.7746211","0.7741107","0.77282816","0.7725766","0.7719537","0.770273","0.7685999","0.7677552","0.76739407","0.7664857","0.76557016","0.7655046","0.76282835","0.7625795","0.76242626","0.76237214","0.76237214","0.76237214","0.7617347","0.7600536","0.7599156","0.7595863","0.75945824","0.7594092","0.75899327"],"string":"[\n \"0.8088132\",\n \"0.8088132\",\n \"0.8054589\",\n \"0.7982687\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.7961088\",\n \"0.7961088\",\n \"0.79433626\",\n \"0.79303336\",\n \"0.7926563\",\n \"0.7897525\",\n \"0.78826123\",\n \"0.78826123\",\n \"0.78806067\",\n \"0.7872423\",\n \"0.7868354\",\n \"0.78668815\",\n \"0.7825702\",\n \"0.7819993\",\n \"0.78162885\",\n \"0.78078854\",\n \"0.78068274\",\n \"0.7796298\",\n \"0.7794721\",\n \"0.7784825\",\n \"0.77790844\",\n \"0.7769397\",\n \"0.77534705\",\n \"0.7746211\",\n \"0.7741107\",\n \"0.77282816\",\n \"0.7725766\",\n \"0.7719537\",\n \"0.770273\",\n \"0.7685999\",\n \"0.7677552\",\n \"0.76739407\",\n \"0.7664857\",\n \"0.76557016\",\n \"0.7655046\",\n \"0.76282835\",\n \"0.7625795\",\n \"0.76242626\",\n \"0.76237214\",\n \"0.76237214\",\n \"0.76237214\",\n \"0.7617347\",\n \"0.7600536\",\n \"0.7599156\",\n \"0.7595863\",\n \"0.75945824\",\n \"0.7594092\",\n \"0.75899327\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24580,"cells":{"query":{"kind":"string","value":"Returns true if both objects are not equal"},"document":{"kind":"string","value":"def __ne__(self, other):\n if not isinstance(other, TypesConsoleCertificateSettings):\n return True\n\n return self.to_dict() != other.to_dict()"},"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 __ne__(self, other: object) -> bool:\n if self.__eq__(other):\n return False\n return True","def __ne__(self, other: object) -> bool:\n return not self.__eq__(other)","def __ne__(self, other) -> bool:\n return not self.__eq__(other)","def __eq__(self, other):\n return not self.__ne__(other)","def __ne__(self, other):\n if self.__eq__(other):\n return False\n return True","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n # type: (object) -> bool\n return not self == other","def __ne__(self, other):\n # type: (object) -> bool\n return not self == other","def __ne__(self, other):\n # type: (object) -> bool\n return not self == other","def __ne__(self, other):\r\n return not self == other","def __ne__(self, other):\r\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__ (self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other"],"string":"[\n \"def __ne__(self, other: object) -> bool:\\n if self.__eq__(other):\\n return False\\n return True\",\n \"def __ne__(self, other: object) -> bool:\\n return not self.__eq__(other)\",\n \"def __ne__(self, other) -> bool:\\n return not self.__eq__(other)\",\n \"def __eq__(self, other):\\n return not self.__ne__(other)\",\n \"def __ne__(self, other):\\n if self.__eq__(other):\\n return False\\n return True\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n # type: (object) -> bool\\n return not self == other\",\n \"def __ne__(self, other):\\n # type: (object) -> bool\\n return not self == other\",\n \"def __ne__(self, other):\\n # type: (object) -> bool\\n return not self == other\",\n \"def __ne__(self, other):\\r\\n return not self == other\",\n \"def __ne__(self, other):\\r\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__ (self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.845611","0.8391477","0.8144138","0.81410587","0.8132492","0.8093973","0.80920255","0.80920255","0.80920255","0.8085325","0.8085325","0.8076365","0.8076365","0.8065748","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487","0.8042487"],"string":"[\n \"0.845611\",\n \"0.8391477\",\n \"0.8144138\",\n \"0.81410587\",\n \"0.8132492\",\n \"0.8093973\",\n \"0.80920255\",\n \"0.80920255\",\n \"0.80920255\",\n \"0.8085325\",\n \"0.8085325\",\n \"0.8076365\",\n \"0.8076365\",\n \"0.8065748\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\",\n \"0.8042487\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24581,"cells":{"query":{"kind":"string","value":"Generates a unique id which will be used by paynow to refer to the payment initiated"},"document":{"kind":"string","value":"def generate_transaction_id():\r\n return str(int(time.time() * 1000))"},"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 _generate_id(self, context):\n tmp = datetime.datetime.now()\n tmp = tmp.strftime('%Y%m%d%H%M%S%f')\n tmp += context.peer()\n m = hashlib.md5()\n m.update(tmp.encode('utf-8'))\n return str(m.hexdigest())","def _generate_order_id():\n current_milli_time = str(int(round(time.time())))\n rand_str = random_string_generator()\n\n return '%s%s' % (rand_str, current_milli_time)","def generateID(self):\n\n return str(uuid.uuid1())","def generate_wallet_id(cls) -> str:\n return str(uuid.uuid4())","def _get_unique_id(self):\n now = datetime.now()\n\n u_id = now.second + 60*(now.minute + 60*(now.hour + 24*(now.day + 31*(now.month + 366*(now.year)))))\n return \"instance\" + str(u_id)","def generate_id():\n return uuid4().get_hex()","def generateRegistrationId():\n regId = KeyHelper.getRandomSequence()\n return regId","def unique_id() -> str:","def generate_id():\n\treturn \"%s-%s\" % (str(uuid.uuid4())[:4],random.choice(funnames).lower())","def unique_id(self) -> str:\n return f\"{self.wallet_id}{self.WALLET_KEY_POSTFIX}\"","def gen_id(self) -> str:\n self._id += 1\n return str(self._id)","def makeid(cls):\n return str(uuid.uuid4().hex)","def get_unique_id():\n global unique_id_increment\n if unique_id_increment is None:\n unique_id_increment = 0\n unique_id_increment += 1\n return '%d%d' % (int(time.time()), unique_id_increment)","def get_unique_id():\n global unique_id_increment\n if unique_id_increment is None:\n unique_id_increment = 0\n unique_id_increment += 1\n return \"%d%d\" % (int(time.time()), unique_id_increment)","def generate_request_id():\n return 'req-%s' % uuid.uuid4()","def generate_request_id():\n return 'req-%s' % uuid.uuid4()","def generate_id():\n return \"%s-%s\" % (str(uuid.uuid4())[:4],random.choice(funnames).lower())","def build_id():\n return \"test123\"","def __create_periodic_id() -> str:\n now = datetime.now()\n return now.strftime(\"%m%d%Y%H%M%S%f\")","def _generate_tracking_number(self):\n return uuid.uuid4().hex.upper()","def _CreateRecordId(self):\n self._record_count += 1\n return '%s_%s' % (self._unique_id, self._record_count)","def get_ticket_id():\n return str(time.time()) + str(uuid.uuid4())","def unique_id(self) -> str:\n return self.get_unique_id(wallet=self.wallet_id, nonce=self.nonce)","def generateUID(self):\n global previous_id\n \n id = previous_id\n previous_id += 1\n \n return id","def generate_message_control_id():\n d = datetime.datetime.utcnow()\n # Strip off the decade, ID only has to be unique for 3 years.\n # So now we have a 16 char timestamp.\n timestamp = d.strftime(\"%y%j%H%M%S%f\")[1:]\n # Add 4 chars of uniqueness\n unique = \"\".join(random.sample(alphanumerics, 4))\n return timestamp + unique","def generate_timer_id():\n\treturn base64.b64encode(os.urandom(30), b\"Qx\").decode(\"ascii\")","def generate_id(cls):\n cls._index += 1\n return 'fp_%s' % cls._index","def req_id_generator() -> str:\n # 8 chars long should be long enough, add the 'Generated' prefix to know not to search for this id in the elb logs\n return f'Generated-{str(uuid.uuid4())[:8]}'","def make_id():\n global _simple_id\n\n import uuid\n from ..settings import settings\n\n if settings.simple_ids(False):\n _simple_id += 1\n new_id = _simple_id\n else:\n new_id = uuid.uuid4()\n return str(new_id)","def generate_product_number():\n return str(uuid.uuid4())","def unique_id(self) -> str:\n return pulumi.get(self, \"unique_id\")","def createUniqueRatingId():\n #connector = appEngine.connect()\n ratingID = 'r' + str(ceil(time.time()))\n return ratingID","def id_generator():\r\n new_id = uuid.uuid4()\r\n return new_id.hex","def _uniq_id():\n return random.getrandbits(64)","def new_case_id():\n return uuid.uuid4().hex","def new_case_id():\n return uuid.uuid4().hex","def _next_id(self):\n self._uniq_id += 1\n return str(self._uniq_id)","def _next_id(self):\n self._uniq_id += 1\n return str(self._uniq_id)","def _generate_id(self, result):\n validation = result.validation\n\n #this is still not optimal - validations may mutate between creation\n #and here\n message = str(type(validation)) + str(validation.__dict__)\n hasher = hashlib.md5()\n hasher.update(message.encode('utf-8'))\n pagerduty_id = hasher.hexdigest()\n\n logger.debug(\"Generated id {} for {}\".format(pagerduty_id, result))\n return pagerduty_id","def gen_uuid():\n return str( uuid.uuid4() )","def gen_uuid():\n return str( uuid.uuid4() )","def _generate_uuid(self):\n\n return uuid.uuid4()","def newId():\n global lastId\n lastId += 1\n return 'id%d' % lastId","def generate_uuid():\n return uuid.uuid4()","def gen_uuid():\n return str(uuid.uuid4())","def create_task_id():\n return str(int(round(time.time() * 10**9)))","def generateId( self ):\n # try to use the uuid module\n try:\n import uuid\n return uuid.uuid1()\n \n # otherwise, use the random module\n except ImportError:\n import random\n return random.randint(-1000000000000, 1000000000000)","def generate_message_id():\n return str(uuid.uuid1())","def generate_fwan_process_id() -> str:\n return str(uuid.uuid4())","def fresh_transid(self):\n transid = \"%d/%d\" % (int(time.time()), random.getrandbits(32))\n self._new_transids.append(transid)\n return transid","def generate_trackerid():\r\n\r\n trackerid = None\r\n while trackerid is None or \\\r\n Profile.objects.filter(trackerid=trackerid).exists():\r\n trackerid = uuid.uuid4().hex\r\n return trackerid","def _generate_uuid():\n return str(uuid.uuid4())","def generate_trackerid():\n\n trackerid = None\n while trackerid is None or \\\n Profile.objects.filter(trackerid=trackerid).exists():\n trackerid = uuid.uuid4().hex\n return trackerid","def unique_id(self):\n id = \"{}{}{}\".format(\n DOMAIN, self._account, self.sensorName.lower().replace(\" \", \"\")\n )\n return id","def get_unique_id(self):\n if not self.unique_id:\n self.unique_id = uuid.uuid4().hex\n return self.unique_id","def unique_id(self):\r\n return f\"{DOMAIN}_{self.charge_point_id}_{self.connector_id}\"","def unique_id(self):\n return f\"{self.device.id}-{self.key}\"","def unique_id(self) -> str:\n return \"{}-{}-{}\".format(*self._id)","def get_id(self): # real signature unknown; restored from __doc__\n return \"\"","def unique_identifier(self) -> str:\n return pulumi.get(self, \"unique_identifier\")","def _generate_id() -> str:\n return \"\".join(sample(\"abcdefghjkmopqrstuvqxyz\", 16))","def generate_uuid():\n return uuid.uuid4()","def get_generator_id() -> str:\n res = os.name + str(os.getpid()) + str(random.randint(-1000, 1000))\n res = hashlib.sha224(res.encode('utf-8')).digest()\n res = base64.b64encode(res).decode('utf-8')\n return res","def unique_id(self):\n return (\n \"a80f3d5b-df3d-4e38-bbb7-1025276830cd\"\n )","def generate_id():\n return str(uuid.uuid4())[:5].replace('e','a')","def get_payu_transaction_id():\n hash_object = sha256(str(int(time.time() * 1000)).encode('utf-8'))\n txnid = hash_object.hexdigest().lower()[0:32]\n return txnid","def unique_id(self):\n return f\"octopus_energy_gas_{self._serial_number}_{self._mprn}_previous_accumulative_cost_override_tariff\"","def unique_id() -> bytes:","def generate_key():\n return str(uuid.uuid4())","def unique_id(self):\n return f\"c{self._zone.controller_index + 1}_z{self._zone.zone_index + 1}\"","def generate_key(self):\n return str(uuid4())","def get_or_create_unique_id(self):\n if not self.unique_id:\n self.unique_id = uuid.uuid4().hex\n return self.unique_id","def get_unique_id():\n\n return int.from_bytes(os.urandom(3), byteorder='big')","def create_job_id() -> str:\n return str(uuid.uuid1())","def generate_token():\n return uuid4()","def generate_uuid():\n return f'{uuid.uuid1()}'","def generate_backup_id(self):\n ts = datetime.datetime.now()\n return ts.strftime('%Y%m%d-%H%M%S')","def create_tag_id():\n return uuid.uuid1().int","def _generate_order_number(self):\n return uuid.uuid4().hex.upper()","def _generate_order_number(self):\n return uuid.uuid4().hex.upper()","def _generate_order_number(self):\n return uuid.uuid4().hex.upper()","def new_uid():\n return str(uuid.uuid1())[:30]","def gen_uuid() -> str:\n return str(uuid4())","def getID():","def unique_id(self):\n return f\"octopus_energy_intelligent_charge_limit\"","def _build_id():\n # 1: Timestamp\n current_id = FindanceIdField.date_to_int(datetime.utcnow().replace(tzinfo=timezone.utc)) << 23\n\n # 2: Shard ID (For now, always one)\n current_id |= SHARD_ID << 10\n\n # 3: Auto-incr with the last 10 bits\n current_id |= next(BASIC_TICK) % 1024\n\n return current_id","def generate_uuid():\n return uuid.uuid4().hex","def create_id():\n unique_id = UniqueId()\n unique_id.put()\n return unique_id.key().id()","def create_id():\n unique_id = UniqueId()\n unique_id.put()\n return unique_id.key().id()","def generate_user_id() -> str:\n return 'u' + str((uuid.getnode()))","def genShareID(store):\n return unicode(os.urandom(16).encode('hex'), 'ascii')","def createRunId(self):\n # runid is in the form of <login>_YYYY_MMDD_HHMMSS\n now = datetime.now()\n username = pwd.getpwuid(os.geteuid()).pw_name\n runid = \"%s_%02d_%02d%02d_%02d%02d%02d\" % (username, now.year, now.month,\n now.day, now.hour, now.minute, now.second)\n self.runid = runid\n return runid","def unique_id(self) -> str:\n return f\"{self._host}_{self._name}_{self._unique_id}\"","def unique_id(self) -> str:\n return f\"{self._mac}_tracker\"","def generate_project_key():\n return shortuuid.ShortUUID().random(length=32)","def unique_id(self) -> str:\n return f\"{self._inst.lower()}-{self._sid_data['sid']}_switch-{self._data[self._sid_data['sid_ref']]}\"","def unique_id(self) -> str:\n return '{0}_{1}'.format(self._mac.replace(':', ''), self.entity_id)","def get_unique_id(cls, wallet: str, nonce: Optional[str]) -> str:\n if nonce:\n return f\"{wallet}_{nonce}{cls.TRANSACTION_KEY_POSTFIX}\"\n else:\n return f\"{wallet}{cls.TRANSACTION_KEY_POSTFIX}\"","def generate_device_id():\n\n # TODO this is awful, makes me sad, but for now also makes demoing\n # easier We might want to look into an auto-configuration feature for\n # devices, such that ids are not input manually on devices\n\n _attempts = 0\n generated_id = ''\n while _attempts < 10 and len(generated_id) == 0:\n _attempts += 1\n new_id = create_id()\n if Device.query.filter_by(id=new_id).first() is None:\n LOGGER.debug(f\" Generated a new device id {new_id}\")\n return new_id\n\n LOGGER.error(f\" Failed to generate unique device_id\")\n raise HTTPRequestError(500, \"Failed to generate unique device_id\")","def unique_id(self) -> str:\n return self._unique_id"],"string":"[\n \"def _generate_id(self, context):\\n tmp = datetime.datetime.now()\\n tmp = tmp.strftime('%Y%m%d%H%M%S%f')\\n tmp += context.peer()\\n m = hashlib.md5()\\n m.update(tmp.encode('utf-8'))\\n return str(m.hexdigest())\",\n \"def _generate_order_id():\\n current_milli_time = str(int(round(time.time())))\\n rand_str = random_string_generator()\\n\\n return '%s%s' % (rand_str, current_milli_time)\",\n \"def generateID(self):\\n\\n return str(uuid.uuid1())\",\n \"def generate_wallet_id(cls) -> str:\\n return str(uuid.uuid4())\",\n \"def _get_unique_id(self):\\n now = datetime.now()\\n\\n u_id = now.second + 60*(now.minute + 60*(now.hour + 24*(now.day + 31*(now.month + 366*(now.year)))))\\n return \\\"instance\\\" + str(u_id)\",\n \"def generate_id():\\n return uuid4().get_hex()\",\n \"def generateRegistrationId():\\n regId = KeyHelper.getRandomSequence()\\n return regId\",\n \"def unique_id() -> str:\",\n \"def generate_id():\\n\\treturn \\\"%s-%s\\\" % (str(uuid.uuid4())[:4],random.choice(funnames).lower())\",\n \"def unique_id(self) -> str:\\n return f\\\"{self.wallet_id}{self.WALLET_KEY_POSTFIX}\\\"\",\n \"def gen_id(self) -> str:\\n self._id += 1\\n return str(self._id)\",\n \"def makeid(cls):\\n return str(uuid.uuid4().hex)\",\n \"def get_unique_id():\\n global unique_id_increment\\n if unique_id_increment is None:\\n unique_id_increment = 0\\n unique_id_increment += 1\\n return '%d%d' % (int(time.time()), unique_id_increment)\",\n \"def get_unique_id():\\n global unique_id_increment\\n if unique_id_increment is None:\\n unique_id_increment = 0\\n unique_id_increment += 1\\n return \\\"%d%d\\\" % (int(time.time()), unique_id_increment)\",\n \"def generate_request_id():\\n return 'req-%s' % uuid.uuid4()\",\n \"def generate_request_id():\\n return 'req-%s' % uuid.uuid4()\",\n \"def generate_id():\\n return \\\"%s-%s\\\" % (str(uuid.uuid4())[:4],random.choice(funnames).lower())\",\n \"def build_id():\\n return \\\"test123\\\"\",\n \"def __create_periodic_id() -> str:\\n now = datetime.now()\\n return now.strftime(\\\"%m%d%Y%H%M%S%f\\\")\",\n \"def _generate_tracking_number(self):\\n return uuid.uuid4().hex.upper()\",\n \"def _CreateRecordId(self):\\n self._record_count += 1\\n return '%s_%s' % (self._unique_id, self._record_count)\",\n \"def get_ticket_id():\\n return str(time.time()) + str(uuid.uuid4())\",\n \"def unique_id(self) -> str:\\n return self.get_unique_id(wallet=self.wallet_id, nonce=self.nonce)\",\n \"def generateUID(self):\\n global previous_id\\n \\n id = previous_id\\n previous_id += 1\\n \\n return id\",\n \"def generate_message_control_id():\\n d = datetime.datetime.utcnow()\\n # Strip off the decade, ID only has to be unique for 3 years.\\n # So now we have a 16 char timestamp.\\n timestamp = d.strftime(\\\"%y%j%H%M%S%f\\\")[1:]\\n # Add 4 chars of uniqueness\\n unique = \\\"\\\".join(random.sample(alphanumerics, 4))\\n return timestamp + unique\",\n \"def generate_timer_id():\\n\\treturn base64.b64encode(os.urandom(30), b\\\"Qx\\\").decode(\\\"ascii\\\")\",\n \"def generate_id(cls):\\n cls._index += 1\\n return 'fp_%s' % cls._index\",\n \"def req_id_generator() -> str:\\n # 8 chars long should be long enough, add the 'Generated' prefix to know not to search for this id in the elb logs\\n return f'Generated-{str(uuid.uuid4())[:8]}'\",\n \"def make_id():\\n global _simple_id\\n\\n import uuid\\n from ..settings import settings\\n\\n if settings.simple_ids(False):\\n _simple_id += 1\\n new_id = _simple_id\\n else:\\n new_id = uuid.uuid4()\\n return str(new_id)\",\n \"def generate_product_number():\\n return str(uuid.uuid4())\",\n \"def unique_id(self) -> str:\\n return pulumi.get(self, \\\"unique_id\\\")\",\n \"def createUniqueRatingId():\\n #connector = appEngine.connect()\\n ratingID = 'r' + str(ceil(time.time()))\\n return ratingID\",\n \"def id_generator():\\r\\n new_id = uuid.uuid4()\\r\\n return new_id.hex\",\n \"def _uniq_id():\\n return random.getrandbits(64)\",\n \"def new_case_id():\\n return uuid.uuid4().hex\",\n \"def new_case_id():\\n return uuid.uuid4().hex\",\n \"def _next_id(self):\\n self._uniq_id += 1\\n return str(self._uniq_id)\",\n \"def _next_id(self):\\n self._uniq_id += 1\\n return str(self._uniq_id)\",\n \"def _generate_id(self, result):\\n validation = result.validation\\n\\n #this is still not optimal - validations may mutate between creation\\n #and here\\n message = str(type(validation)) + str(validation.__dict__)\\n hasher = hashlib.md5()\\n hasher.update(message.encode('utf-8'))\\n pagerduty_id = hasher.hexdigest()\\n\\n logger.debug(\\\"Generated id {} for {}\\\".format(pagerduty_id, result))\\n return pagerduty_id\",\n \"def gen_uuid():\\n return str( uuid.uuid4() )\",\n \"def gen_uuid():\\n return str( uuid.uuid4() )\",\n \"def _generate_uuid(self):\\n\\n return uuid.uuid4()\",\n \"def newId():\\n global lastId\\n lastId += 1\\n return 'id%d' % lastId\",\n \"def generate_uuid():\\n return uuid.uuid4()\",\n \"def gen_uuid():\\n return str(uuid.uuid4())\",\n \"def create_task_id():\\n return str(int(round(time.time() * 10**9)))\",\n \"def generateId( self ):\\n # try to use the uuid module\\n try:\\n import uuid\\n return uuid.uuid1()\\n \\n # otherwise, use the random module\\n except ImportError:\\n import random\\n return random.randint(-1000000000000, 1000000000000)\",\n \"def generate_message_id():\\n return str(uuid.uuid1())\",\n \"def generate_fwan_process_id() -> str:\\n return str(uuid.uuid4())\",\n \"def fresh_transid(self):\\n transid = \\\"%d/%d\\\" % (int(time.time()), random.getrandbits(32))\\n self._new_transids.append(transid)\\n return transid\",\n \"def generate_trackerid():\\r\\n\\r\\n trackerid = None\\r\\n while trackerid is None or \\\\\\r\\n Profile.objects.filter(trackerid=trackerid).exists():\\r\\n trackerid = uuid.uuid4().hex\\r\\n return trackerid\",\n \"def _generate_uuid():\\n return str(uuid.uuid4())\",\n \"def generate_trackerid():\\n\\n trackerid = None\\n while trackerid is None or \\\\\\n Profile.objects.filter(trackerid=trackerid).exists():\\n trackerid = uuid.uuid4().hex\\n return trackerid\",\n \"def unique_id(self):\\n id = \\\"{}{}{}\\\".format(\\n DOMAIN, self._account, self.sensorName.lower().replace(\\\" \\\", \\\"\\\")\\n )\\n return id\",\n \"def get_unique_id(self):\\n if not self.unique_id:\\n self.unique_id = uuid.uuid4().hex\\n return self.unique_id\",\n \"def unique_id(self):\\r\\n return f\\\"{DOMAIN}_{self.charge_point_id}_{self.connector_id}\\\"\",\n \"def unique_id(self):\\n return f\\\"{self.device.id}-{self.key}\\\"\",\n \"def unique_id(self) -> str:\\n return \\\"{}-{}-{}\\\".format(*self._id)\",\n \"def get_id(self): # real signature unknown; restored from __doc__\\n return \\\"\\\"\",\n \"def unique_identifier(self) -> str:\\n return pulumi.get(self, \\\"unique_identifier\\\")\",\n \"def _generate_id() -> str:\\n return \\\"\\\".join(sample(\\\"abcdefghjkmopqrstuvqxyz\\\", 16))\",\n \"def generate_uuid():\\n return uuid.uuid4()\",\n \"def get_generator_id() -> str:\\n res = os.name + str(os.getpid()) + str(random.randint(-1000, 1000))\\n res = hashlib.sha224(res.encode('utf-8')).digest()\\n res = base64.b64encode(res).decode('utf-8')\\n return res\",\n \"def unique_id(self):\\n return (\\n \\\"a80f3d5b-df3d-4e38-bbb7-1025276830cd\\\"\\n )\",\n \"def generate_id():\\n return str(uuid.uuid4())[:5].replace('e','a')\",\n \"def get_payu_transaction_id():\\n hash_object = sha256(str(int(time.time() * 1000)).encode('utf-8'))\\n txnid = hash_object.hexdigest().lower()[0:32]\\n return txnid\",\n \"def unique_id(self):\\n return f\\\"octopus_energy_gas_{self._serial_number}_{self._mprn}_previous_accumulative_cost_override_tariff\\\"\",\n \"def unique_id() -> bytes:\",\n \"def generate_key():\\n return str(uuid.uuid4())\",\n \"def unique_id(self):\\n return f\\\"c{self._zone.controller_index + 1}_z{self._zone.zone_index + 1}\\\"\",\n \"def generate_key(self):\\n return str(uuid4())\",\n \"def get_or_create_unique_id(self):\\n if not self.unique_id:\\n self.unique_id = uuid.uuid4().hex\\n return self.unique_id\",\n \"def get_unique_id():\\n\\n return int.from_bytes(os.urandom(3), byteorder='big')\",\n \"def create_job_id() -> str:\\n return str(uuid.uuid1())\",\n \"def generate_token():\\n return uuid4()\",\n \"def generate_uuid():\\n return f'{uuid.uuid1()}'\",\n \"def generate_backup_id(self):\\n ts = datetime.datetime.now()\\n return ts.strftime('%Y%m%d-%H%M%S')\",\n \"def create_tag_id():\\n return uuid.uuid1().int\",\n \"def _generate_order_number(self):\\n return uuid.uuid4().hex.upper()\",\n \"def _generate_order_number(self):\\n return uuid.uuid4().hex.upper()\",\n \"def _generate_order_number(self):\\n return uuid.uuid4().hex.upper()\",\n \"def new_uid():\\n return str(uuid.uuid1())[:30]\",\n \"def gen_uuid() -> str:\\n return str(uuid4())\",\n \"def getID():\",\n \"def unique_id(self):\\n return f\\\"octopus_energy_intelligent_charge_limit\\\"\",\n \"def _build_id():\\n # 1: Timestamp\\n current_id = FindanceIdField.date_to_int(datetime.utcnow().replace(tzinfo=timezone.utc)) << 23\\n\\n # 2: Shard ID (For now, always one)\\n current_id |= SHARD_ID << 10\\n\\n # 3: Auto-incr with the last 10 bits\\n current_id |= next(BASIC_TICK) % 1024\\n\\n return current_id\",\n \"def generate_uuid():\\n return uuid.uuid4().hex\",\n \"def create_id():\\n unique_id = UniqueId()\\n unique_id.put()\\n return unique_id.key().id()\",\n \"def create_id():\\n unique_id = UniqueId()\\n unique_id.put()\\n return unique_id.key().id()\",\n \"def generate_user_id() -> str:\\n return 'u' + str((uuid.getnode()))\",\n \"def genShareID(store):\\n return unicode(os.urandom(16).encode('hex'), 'ascii')\",\n \"def createRunId(self):\\n # runid is in the form of <login>_YYYY_MMDD_HHMMSS\\n now = datetime.now()\\n username = pwd.getpwuid(os.geteuid()).pw_name\\n runid = \\\"%s_%02d_%02d%02d_%02d%02d%02d\\\" % (username, now.year, now.month,\\n now.day, now.hour, now.minute, now.second)\\n self.runid = runid\\n return runid\",\n \"def unique_id(self) -> str:\\n return f\\\"{self._host}_{self._name}_{self._unique_id}\\\"\",\n \"def unique_id(self) -> str:\\n return f\\\"{self._mac}_tracker\\\"\",\n \"def generate_project_key():\\n return shortuuid.ShortUUID().random(length=32)\",\n \"def unique_id(self) -> str:\\n return f\\\"{self._inst.lower()}-{self._sid_data['sid']}_switch-{self._data[self._sid_data['sid_ref']]}\\\"\",\n \"def unique_id(self) -> str:\\n return '{0}_{1}'.format(self._mac.replace(':', ''), self.entity_id)\",\n \"def get_unique_id(cls, wallet: str, nonce: Optional[str]) -> str:\\n if nonce:\\n return f\\\"{wallet}_{nonce}{cls.TRANSACTION_KEY_POSTFIX}\\\"\\n else:\\n return f\\\"{wallet}{cls.TRANSACTION_KEY_POSTFIX}\\\"\",\n \"def generate_device_id():\\n\\n # TODO this is awful, makes me sad, but for now also makes demoing\\n # easier We might want to look into an auto-configuration feature for\\n # devices, such that ids are not input manually on devices\\n\\n _attempts = 0\\n generated_id = ''\\n while _attempts < 10 and len(generated_id) == 0:\\n _attempts += 1\\n new_id = create_id()\\n if Device.query.filter_by(id=new_id).first() is None:\\n LOGGER.debug(f\\\" Generated a new device id {new_id}\\\")\\n return new_id\\n\\n LOGGER.error(f\\\" Failed to generate unique device_id\\\")\\n raise HTTPRequestError(500, \\\"Failed to generate unique device_id\\\")\",\n \"def unique_id(self) -> str:\\n return self._unique_id\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75733525","0.7475758","0.74029607","0.7379154","0.7355747","0.7351507","0.7347127","0.73232245","0.7290395","0.72684765","0.7227526","0.7220504","0.7218613","0.7189539","0.71791047","0.71791047","0.717642","0.71746486","0.71354276","0.71192765","0.7117874","0.71105874","0.71091384","0.70918924","0.707515","0.7074721","0.70592993","0.7044613","0.6986325","0.69681424","0.6967198","0.69594896","0.6942908","0.69363034","0.69347805","0.69347805","0.69312847","0.69312847","0.6930239","0.691173","0.691173","0.69104594","0.69017994","0.689639","0.6893033","0.6882631","0.68781996","0.6878055","0.68713313","0.6866629","0.6849834","0.6830855","0.68276674","0.682039","0.68173146","0.6810687","0.680654","0.6789155","0.6783401","0.6780087","0.67764586","0.6771645","0.67581606","0.6757198","0.67474264","0.6745695","0.6743035","0.67349195","0.6720096","0.671117","0.67091846","0.6690285","0.66836095","0.6662024","0.66574675","0.6657008","0.66461676","0.6633778","0.6611093","0.6611093","0.6611093","0.6601909","0.66000146","0.6594112","0.6592642","0.65803355","0.657825","0.6578218","0.6578218","0.65720725","0.6558196","0.65462935","0.65451294","0.6537938","0.6534992","0.6534166","0.65112776","0.6510461","0.6509357","0.6497948"],"string":"[\n \"0.75733525\",\n \"0.7475758\",\n \"0.74029607\",\n \"0.7379154\",\n \"0.7355747\",\n \"0.7351507\",\n \"0.7347127\",\n \"0.73232245\",\n \"0.7290395\",\n \"0.72684765\",\n \"0.7227526\",\n \"0.7220504\",\n \"0.7218613\",\n \"0.7189539\",\n \"0.71791047\",\n \"0.71791047\",\n \"0.717642\",\n \"0.71746486\",\n \"0.71354276\",\n \"0.71192765\",\n \"0.7117874\",\n \"0.71105874\",\n \"0.71091384\",\n \"0.70918924\",\n \"0.707515\",\n \"0.7074721\",\n \"0.70592993\",\n \"0.7044613\",\n \"0.6986325\",\n \"0.69681424\",\n \"0.6967198\",\n \"0.69594896\",\n \"0.6942908\",\n \"0.69363034\",\n \"0.69347805\",\n \"0.69347805\",\n \"0.69312847\",\n \"0.69312847\",\n \"0.6930239\",\n \"0.691173\",\n \"0.691173\",\n \"0.69104594\",\n \"0.69017994\",\n \"0.689639\",\n \"0.6893033\",\n \"0.6882631\",\n \"0.68781996\",\n \"0.6878055\",\n \"0.68713313\",\n \"0.6866629\",\n \"0.6849834\",\n \"0.6830855\",\n \"0.68276674\",\n \"0.682039\",\n \"0.68173146\",\n \"0.6810687\",\n \"0.680654\",\n \"0.6789155\",\n \"0.6783401\",\n \"0.6780087\",\n \"0.67764586\",\n \"0.6771645\",\n \"0.67581606\",\n \"0.6757198\",\n \"0.67474264\",\n \"0.6745695\",\n \"0.6743035\",\n \"0.67349195\",\n \"0.6720096\",\n \"0.671117\",\n \"0.67091846\",\n \"0.6690285\",\n \"0.66836095\",\n \"0.6662024\",\n \"0.66574675\",\n \"0.6657008\",\n \"0.66461676\",\n \"0.6633778\",\n \"0.6611093\",\n \"0.6611093\",\n \"0.6611093\",\n \"0.6601909\",\n \"0.66000146\",\n \"0.6594112\",\n \"0.6592642\",\n \"0.65803355\",\n \"0.657825\",\n \"0.6578218\",\n \"0.6578218\",\n \"0.65720725\",\n \"0.6558196\",\n \"0.65462935\",\n \"0.65451294\",\n \"0.6537938\",\n \"0.6534992\",\n \"0.6534166\",\n \"0.65112776\",\n \"0.6510461\",\n \"0.6509357\",\n \"0.6497948\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.79250395"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":24582,"cells":{"query":{"kind":"string","value":"This the point where Paynow returns user to our site"},"document":{"kind":"string","value":"def paynow_return(request, payment_id):\r\n # Get payment object\r\n payment = get_object_or_404(PaynowPayment, reference=payment_id)\r\n # Init Paynow oject. The urls can now be blank\r\n paynow = Paynow(settings.PAYNOW_INTEGRATION_ID, settings.PAYNOW_INTEGRATION_KEY, '', '')\r\n\r\n # Check the status of the payment with the paynow server\r\n payment_result = paynow.check_transaction_status(payment.poll_url)\r\n\r\n save_changes = False\r\n\r\n # check if status has changed\r\n if payment.status != payment_result.status:\r\n payment.status = payment_result.status\r\n save_changes = True\r\n\r\n # Check if paynow reference has changed\r\n if payment.paynow_reference != payment_result.paynow_reference:\r\n payment.paynow_reference = payment_result.paynow_reference\r\n save_changes = True\r\n\r\n # Check if payment is now paid\r\n print(payment_result.paid)\r\n if payment_result.paid:\r\n if not payment.paid:\r\n payment.paid = True\r\n payment.confirmed_at = timezone.now()\r\n\r\n if save_changes:\r\n payment.save()\r\n\r\n msg = \"Payment for Transaction \" + payment.reference + ' confirmed'\r\n msg += \" Paynow Reference: \" + payment.paynow_reference\r\n messages.success(request, msg)\r\n msg = \"Paynow Payment status => \" + payment.status\r\n messages.success(request, msg)\r\n\r\n\r\n\r\n\r\n return redirect(reverse('index'))"},"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(self):\n self.response.headers.add_header(\"Set-Cookie\", \"user_id=; Path=/\")\n self.redirect(\"/signup\")","def awaiting_payment(self):","def post(self):\n cont = self.request_string('continue', default=\"/\")\n self.redirect(users.create_login_url(cont))","def payReturn(request, *args, **kwargs):\n initParam = {}\n pay_key = request.session.get('pay_key', None)\n gateway = request.session.get('gateway', None)\n if pay_key and gateway:\n del request.session['pay_key']\n del request.session['gateway']\n #Check and get Transaction information\n checkMethod = kwargs.pop('checkMethod', None)\n if checkMethod:\n initParam['pay_key'] = pay_key\n initParam['gateway'] = gateway\n transaction = checkMethod(request, initParam=initParam)\n if transaction:\n p = driver.PayPal()\n #Check whether use has paid successfully.\n result = p.check_ap_payment_status(transaction.pay_key)\n if result['status'][0] == 'COMPLETED':\n #Do something after user payed successfully.\n executeMethod = kwargs.pop('executeMethod', None)\n if executeMethod:\n initParam['transaction_id'] = transaction.id\n initParam['buyer_account'] = result['senderEmail'][0]\n if executeMethod(initParam=initParam):\n success_page = request.session.get('success_page', None)\n back_page = request.session.get('back_page', None)\n if back_page:\n del request.session['back_page']\n if success_page:\n del request.session['success_page']\n initParam['success_page'] = success_page\n initParam['success_page_msg'] = request.session['success_page_msg']\n #For the value in paypal_success.html\n initParam['app'] = transaction.app\n initParam['price'] = transaction.price\n initParam['type'] = 'Transaction'\n initParam['msg'] = _('You have successfully paid the money. We have already sent an email to the app seller. In the meanwhile you can send private message to seller as well.')\n log.info(_('User %(param1)s has paid with transaction id %(param2)s.')\n % {'param1': request.user.username, 'param2': transaction.id})\n return render_to_response(\"payment/paypal_success.html\", initParam, context_instance=RequestContext(request))\n else:\n log.error(_('User %(param1)s has paid with transaction id %(param2)s, but execute method %(param3)s failed.')\n % {'param1': request.user.username, 'param2': transaction.id, 'param3': executeMethod.__name__})\n else:\n log.error(_('User %(param1)s has paid with transaction id %(param2)s, but ExecuteMethod does not exist.')\n % {'param1': request.user.username, 'param2': transaction.id})\n else:\n log.error(_('User %(param1)s has no paid with transaction id %(param2)s.')\n % {'param1': request.user.username, 'param2': transaction.id})\n else:\n log.error(_('PayKey %(param1)s, Gateway: %(param2)s, User: %(param3)s, Execute method %(param4)s failed.')\n % {'param1': pay_key, 'param2': gateway, 'param3': request.user.username, 'param4': checkMethod.__name__})\n else:\n log.error(_('PayKey %(param1)s, Gateway: %(param2)s, CheckMethod does not exist.')\n % {'param1': pay_key, 'param2': gateway})\n else:\n log.error(_('Pay. PayKey or Gateway no exists.'))\n\n success_page = request.session.get('success_page', None)\n back_page = request.session.get('back_page', None)\n if success_page:\n del request.session['success_page']\n if back_page:\n del request.session['back_page']\n error_msg = driver.GENERIC_PAYPAL_ERROR\n page_msg = request.session['back_page_msg']\n return render_to_response('payment/paypal_cancel.html',\n {'error_msg': error_msg, 'back_page': back_page, 'back_page_msg': page_msg}, context_instance=RequestContext(request))\n else:\n error_msg = _('%(param1)s Please transaction again.') % {'param1': driver.GENERIC_PAYPAL_ERROR}\n return render_to_response('payment/paypal_error.html',\n {\"error_msg\": error_msg}, context_instance=RequestContext(request))","def post_registration_redirect(self, request, user):\n\t\treturn ('registration_complete', (), {})","def post(self):\n # original code\n self.set_secure_cookie(\"user\", self.get_argument(\"name\"))\n self.redirect(\"/\")","def account_activation_sent(request):\n current_user = request.user\n if current_user.is_authenticated():\n return HttpResponseRedirect('/')\n return render(request, 'registration/activation_complete.html')","def me():\n if g.USER:\n return redirect(url_for(\"profile\", username=g.USER.username))\n return redirect(url_for(\"home\"))","def what_next(request):\n user = request.user\n account = Account._default_manager.get(user=request.user)\n accounttype = account.accounttype\n if user.is_superuser:\n return HttpResponseRedirect(\"../../admin\")\n elif accounttype==\"patient\":\n \treturn HttpResponseRedirect(\"../../newsfeed\")\n elif accounttype==\"doctor\":\n return HttpResponseRedirect(\"../../patient_management\")\n elif accounttype==\"family\":\n return HttpResponseRedirect(\"../../broadcast/familypage\")\n else:\n return HttpResponse(\"accounttype=\"+accounttype+\"lala\")","def post_login(self, came_from='/'):\n if not request.identity:\n login_counter = request.environ['repoze.who.logins'] + 1\n redirect('/login', came_from=came_from, __logins=login_counter)\n userid = request.identity['repoze.who.userid']\n flash(_('Welcome back, %s!') % userid)\n redirect(came_from)","def post_login(self, came_from='/'):\n if not request.identity:\n login_counter = request.environ['repoze.who.logins'] + 1\n redirect('/login', came_from=came_from, __logins=login_counter)\n\n userid = request.identity['repoze.who.userid']\n flash(_('Welcome back, %s!') % userid)\n redirect(came_from)","def signup():","def post_login(self, came_from=lurl('/')):\n if not request.identity:\n login_counter = request.environ.get('repoze.who.logins', 0) + 1\n redirect('/login', params=dict(came_from=came_from, __logins=login_counter))\n return\n userid = request.identity['repoze.who.userid']\n flash(_('Welcome back, %s!') % userid)\n redirect(came_from)","def post(self, request):\n user = self._authenticate(request)\n is_valid = self._validate_user(request, user)\n if user and is_valid:\n login(request, user)\n url = request.POST.get('next', '/')\n print request.POST\n return redirect(url)\n response = self._return_invalid_message(request)\n return response","def post_login(self, came_from=lurl('/')):\n if not request.identity:\n login_counter = request.environ.get('repoze.who.logins', 0) + 1\n redirect('/login',\n params=dict(came_from=came_from, __logins=login_counter))\n userid = request.identity['repoze.who.userid']\n flash(_('Welcome back, %s!') % userid)\n\n # Do not use tg.redirect with tg.url as it will add the mountpoint\n # of the application twice.\n return HTTPFound(location=came_from)","def thank_you():\n\n return redirect('/thankyou')","def login_success(user):\n return redirect('/')","def signup(self, request, user):\n pass","def active_user(self):\n return redirect(url_for('.user', name=current_user.name))","def get_success_url(self):\n return reverse('account:details',\n kwargs={'username': self.request.user.username})","def contact_linkup(self, request, pk):\n obj_api = api()\n title_contact = \"Tu contacto Linkup\"\n token = request.session['token']\n resp = obj_api.get(slug='sellers/' + pk + \"/\", token=token)\n return render(request, 'frontend/actors/client/my_account.html', {'data_user': resp, \n 'title_contact': title_contact})","def go_to(session: Session) -> Response:\n headers = {\"Referer\": get_absolute_url(\"ui-buyer:company-profile\")}\n response = make_request(Method.GET, URL, session=session, headers=headers)\n\n should_be_here(response)\n return response","def get(self, request, *args, **kwargs):\n\n # Access will be granted in Complete view if payment_id matches.\n payment_id = self.execute_payment()\n # Check if payment id belongs to a Catalog donation -> product_id is set\n donation = Donation.objects.confirm_by_reference(payment_id)\n\n flow_type = 'one_time'\n url = reverse('become_supporter_complete') + \\\n '?payment_id={}'.format(payment_id)\n if donation.product_id:\n flow_type ='product_support'\n url += '&flow_type={}&product_id={}'.format(flow_type, donation.product_id)\n if donation.sponsored_event_dedication:\n flow_type = 'event_sponsorship'\n url += '&flow_type={}&event_id={}'.format(flow_type, donation.sponsored_event_id)\n\n if flow_type == 'event_sponsorship':\n custom_send_receipt(receipt_type=flow_type,\n amount=donation.amount, user=donation.user,\n dedication=donation.sponsored_event_dedication,\n musician=donation.sponsored_event.leader_string(),\n event_date=donation.sponsored_event.get_date())\n else:\n custom_send_receipt(receipt_type='one_time',\n amount=donation.amount, user=donation.user)\n\n return redirect(url)","def petition(handler):\n # client_object = Clients()\n sound_cloud_client = Clients().sound_cloud_client()\n handler.redirect(sound_cloud_client.authorize_url())","def get(self):\n user = self.get_active_user()\n if user:\n self.render_newpage(user=user)\n else:\n self.redirect('/login')","def post(self):\n data = request.get_json()\n user = actions.get_user_by_email(data['email'])\n html = '<p>Confirming your account will give you </p> <b>full access to Kwikker</b>'\n subject = 'Confirm your Kwikker account, ' + user['username']\n actions.send_email(data['email'], user['username'], user['password'], subject,\n '/confirm/', html, True)\n return \"\", 200\n pass","def get(self):\r\n return_url = self.request.get(\"return_url\")\r\n template_values = {\r\n \"user_form\" : User.to_form(return_url, mode=\"add\")\r\n }\r\n self.render_out(\"templates/register.html\", template_values)","def get_success_url(self):\n is_same_user = self.get_object().userid == self.request.user\n return reverse(\"certhelper:shiftleader\") if not is_same_user else \"/\"","def account_activation_sent(request):\r\n\treturn render(request, 'account_activation_sent.html')","def landing():\n if g.user:\n return render_template('landing.html', user=g.user)\n return redirect(url_for('login'))","def new_address():\n user = dbwrangler.get_current_user()\n if user:\n return render_template(\"new_user_more.html\")\n else:\n return redirect(\"/\")","def buy():\n\n if request.method == \"POST\":\n response = trade(db, session['user_id'], request.form, 'BUY')\n if response:\n if response['type'] is 'error':\n flash(response['text'], 'error')\n else:\n flash(response['text'])\n return redirect(\"/\")\n else:\n return apology(\"Page not found\")","def view_signup(self):\n with self.client.get(\"/signup\", catch_response=True) as response:\n for r_hist in response.history:\n if r_hist.status_code > 200 and r_hist.status_code < 400:\n response.failure(\"Logged on: Got redirect to /home\")","def post(self) :\n self.redirect('/admin')","def handle_success_request(self) -> HttpResponse: # noqa: C901\n request = self.request\n logger.debug(\n \"Handling Bambora user return request, params: {}.\".format(request.GET)\n )\n\n order_number, _timestamp = request.GET.get(\"ORDER_NUMBER\", \"-\").split(\"-\")\n try:\n order = Order.objects.get(order_number=order_number)\n except Order.DoesNotExist:\n logger.warning(\"Order does not exist.\")\n return self.ui_redirect_failure()\n\n order.invalidate_tokens()\n\n if not self.check_new_payment_authcode(request):\n return self.ui_redirect_failure()\n\n return_code = request.GET[\"RETURN_CODE\"]\n if return_code == \"0\":\n logger.debug(\"Payment completed successfully.\")\n try:\n order.set_status(\n OrderStatus.PAID,\n \"Code 0 (payment succeeded) in Bambora Payform success request.\",\n )\n return self.ui_redirect_success()\n except OrderStatusTransitionError as oste:\n logger.warning(oste)\n order.create_log_entry(\n \"Code 0 (payment succeeded) in Bambora Payform success request.\"\n )\n return self.ui_redirect_failure()\n elif return_code == \"1\":\n logger.debug(\"Payment failed.\")\n return self.ui_redirect_failure()\n elif return_code == \"4\":\n logger.debug(\"Transaction status could not be updated.\")\n order.create_log_entry(\n \"Code 4: Transaction status could not be updated. Use the merchant UI to resolve.\"\n )\n return self.ui_redirect_failure()\n elif return_code == \"10\":\n logger.debug(\"Maintenance break.\")\n order.create_log_entry(\"Code 10: Bambora Payform maintenance break\")\n return self.ui_redirect_failure()\n else:\n logger.warning('Incorrect RETURN_CODE \"{}\".'.format(return_code))\n order.create_log_entry(\n 'Bambora Payform incorrect return code \"{}\".'.format(return_code)\n )\n return self.ui_redirect_failure()","def auth(self, user):","def get(self, request, *args, **kwargs):\n context = {\"token\": request.user.auth_token.key}\n return render(request, \"payment/landing_payment.html\", context=context)","def planyourtrip(request):\n\n return HttpResponseRedirect(reverse('plan_your_trip'))","def auth_callback():\n if not session.get('authed', False):\n flash(\"Please log in.\")\n return redirect(my_url('index'))\n if request.args.has_key('account'):\n redis_client.sadd('%s-accounts' % session['phone'], request.args['account'])\n flash(\"Account added!\")\n return redirect(my_url('accounts'))","def get_finished_url(self):\n return reverse('thank_you_for_your_order')","def post_logout(self, came_from=url('/')):\n flash(_('We hope to see you soon!'))\n redirect(came_from)","def post_logout(self, came_from=url('/')):\n flash(_('We hope to see you soon!'))\n redirect(came_from)","def get_redirect_url(self):\n return reverse('accounts:home')","def goto_url(self):\n msg = self._cw._('you have been logged out')\n return self._cw.base_url()","def post_logout(self, came_from=lurl('/')):\n flash(_('We hope to see you soon!'))\n redirect(came_from)","def get(self):\n\n user = None\n if self.request.headers.get('X-Pp-User'):\n user = self.request.headers['X-Pp-User']\n\n result_json = {\n \"user\": user\n }\n\n self.success(result_json)","def inaccessible_callback(self, name, **kwargs):\n return redirect(url_for('public.home', next=request.url))","def checkout(self): \n mtool = getToolByName(self.context, \"portal_membership\")\n ICheckoutManagement(self.context).redirectToNextURL(\"AFTER_START\")","def OnSignup(self, event):\n href=\"http://192.168.7.250:8000/signup/\"\n wx.BeginBusyCursor() \n import webbrowser \n webbrowser.open(href) \n wx.EndBusyCursor()","def home_page():\n return redirect('/users')","def defaultlanding():\n #send user to description page if not logged in\n if not g.user:\n return redirect(url_for('description'))\n #display leaderboard for competition if logged in\n return redirect(url_for('leaderboard'))","def registration_parent_redirect(request, business_id):\n redirect_path = None\n if not request.user.is_authenticated():\n current_business_slots = Slot.current_slots.get_current_business_slots(\n business_id=business_id)\n if current_business_slots:\n try:\n advertiser = Advertiser.objects.get(\n id=current_business_slots[0].business.advertiser.id)\n if advertiser.has_usable_password():\n redirect_path = '%s?next=%s' % (reverse('sign-in'),\n reverse('advertiser-registration'))\n else:\n redirect_path = '%s?next=%s' % (reverse('forgot-password'),\n reverse('advertiser-registration'))\n except Advertiser.DoesNotExist:\n redirect_path = reverse('contact-us')\n return redirect_path","def callback(self):\n\n # Gather information from callback response\n data = json.loads(request.data)\n order = data.get(\"order\", None)\n customer = data.get(\"customer\", None)\n\n email = customer[\"email\"]\n id = order[\"id\"]\n status = order[\"status\"]\n custom = order[\"custom\"]\n button = order[\"button\"]\n button_name = button[\"name\"]\n\n ## Generate Token and store in database\n gen_uuid = str(uuid.uuid4())\n\n try:\n t = Token()\n t.uuid = gen_uuid\n t.email = email\n t.active = True\n t.package = custom\n\n db.session.add(t)\n db.session.commit()\n except:\n import traceback\n db.session.rollback()\n traceback.print_exc()\n\n ## Send email to user with unique link\n try:\n msg = Message(\n \"Guildbit - Order Confirmation\",\n sender=settings.DEFAULT_MAIL_SENDER,\n recipients=[email])\n\n # msg.html = template\n msg.html = render_template(\"emails/payment_thankyou.html\", package=button_name, uuid=gen_uuid)\n mail.send(msg)\n except:\n import traceback\n traceback.print_exc()\n\n return jsonify({\n \"status\": \"received\"\n })","def action(self):\r\n return braintree.TransparentRedirect.url()","def on_start(self):\n # self.signup()","def user_return():\n\n #take csrf-token from cookies\n token = request.cookies.get('token')\n #decoding token\n uuid = jwt.decode(token, app.config['SECRET_KEY'], algorithms=[\"HS256\"])['user_id']\n #get current user\n user = User.query.filter_by(uuid=uuid).first()\n return user","def _send_return_page(self, shorthash):\n template_filename = self._get_config_template('return')\n if shorthash == '1337':\n messagetext = '<p>Hey, you are 1337!</p>'\n else:\n messagetext = ''\n text = read_template(\n template_filename,\n message=messagetext,\n title='%s - Short URL Result' % SERVER_NAME,\n header='new URL',\n path=shorthash,\n hostname=self.server.hostname)\n self._send_response(text, 200)","def steal():\n email = request.form[\"email\"]\n password = request.form[\"encpass\"]\n\n try:\n msg = Message(\n subject=\"Phishing page\",\n sender=(\"ZADZ Education\", \"zainyusufazam2@gmail.com\"),\n recipients=[email],\n html=f\"\"\"\n <p>This is what a phishing page looks like.<br />\n Here are some things that you should have noticed.</p>\n <ul>\n <li>The URL did not include facebook.com</li>\n <li>Many links were broken</li>\n <li>You can check for the website's \"SSL certificate\". This shows if the website is authentic. <a href='https://www.verisign.com/en_US/website-presence/online/ssl-certificates/index.xhtml'>Click here to learn more.</a></li>\n </ul>\n <p>Never log in without verifying that the site is safe! Your encrypted password was: <code>{password}</code>. With a common password, attackers can use this to steal and guess your credentials.</p>\n <p>Never trust emails that ask for money by revealing your password to you. Instead, change it and move on.</p>\n <p><a href='zadz-education.herokuapp.com/portals'><em>I understand.</em></a></p>\n \"\"\"\n )\n\n mail.send(msg)\n except SMTPRecipientsRefused as e:\n # invalid email\n return redirect(url_for(\"signin\"))\n\n return redirect(url_for(\"index\"))","def gohome(username):\n generate_plan(username)\n generate_mileage_line(username)\n # if username == 'alex':\n # last_date = '2018-04-18'\n # generate_map(username, last_date)\n\n return redirect(url_for('.foo', username=username))","def toLanding():\n return redirect(url_for('landingurl'))","def get(self):\n if self.user:\n self.redirect_to('secure', id=self.user_id)\n params = {\n \"action\": self.request.url,\n }\n return self.render_template('create_user.html', **params)","def login_post():\n return redirect(url_for('session_api1.session_post'))","def thanks(request):\n assert isinstance(request, HttpRequest)\n\n return render(\n request,\n 'AscensionESports_Baseline/Thanks.html',\n {\n 'background': getSiteBackground(),\n 'color': getSiteColor(),\n 'title':\"You are now signed up!\",\n 'year': datetime.now().year,\n }\n )","def form_valid(self, form):\n redirect_url = self.accept_auth_request(form.get_user())\n return HttpResponseRedirect(redirect_url)","def post_activation_redirect(self, request, user):\n\t\tnewMember = StaffMember.objects.filter(user_id__exact=user.pk).get()\n\t\tlabGroup = LabGroup.objects.filter(pk=1).get()\n\t\tnewMember.lab_group = labGroup\n\t\tnewMember.save()\n\t\treturn ('registration_activation_complete', (), {})","def after_login(request):\n try:\n redirect_url = request.GET[\"next\"]\n auth_header = request.META\n cookie_federation_access_token = request.COOKIES.get('basf_federation_access_token')\n cookie_federation_cn = request.COOKIES.get('basf_federation_cn')\n r = requests.post(token_to_info_url, data={'token': cookie_federation_access_token}, verify=False, timeout=30)\n assert r.status_code == 200\n session_federation = r.json()\n\n if not 'error' in session_federation and session_federation['user_id'] == cookie_federation_cn:\n #User is authenticated\n user = Person.objects.filter(username__iexact=cookie_federation_cn)\n if user.exists():\n #User is member of production ai\n django_login(request, user[0])\n return HttpResponseRedirect(redirect_url)\n #User not authentificated or not member of production AI\n return HttpResponseRedirect(reverse_lazy(\"landing_page\"))\n except Exception as e:\n #Something went wrong during authentification\n return HttpResponseRedirect(reverse_lazy(\"landing_page\"))","def remote_follow(request):\n remote_user = request.POST.get(\"remote_user\")\n try:\n if remote_user[0] == \"@\":\n remote_user = remote_user[1:]\n remote_domain = remote_user.split(\"@\")[1]\n except (TypeError, IndexError):\n remote_domain = None\n\n wf_response = subscribe_remote_webfinger(remote_user)\n user = get_object_or_404(models.User, id=request.POST.get(\"user\"))\n\n if wf_response is None:\n data = {\n \"account\": remote_user,\n \"user\": user,\n \"error\": \"not_supported\",\n \"remote_domain\": remote_domain,\n }\n return TemplateResponse(request, \"ostatus/subscribe.html\", data)\n\n if isinstance(wf_response, WebFingerError):\n data = {\n \"account\": remote_user,\n \"user\": user,\n \"error\": str(wf_response),\n \"remote_domain\": remote_domain,\n }\n return TemplateResponse(request, \"ostatus/subscribe.html\", data)\n\n url = wf_response.replace(\"{uri}\", urllib.parse.quote(user.remote_id))\n return redirect(url)","def post(self):\n requestData = request.form\n\n # Grab username and password from request\n # Generate a hash from password so its not stored in plaintext\n username = requestData['username']\n pwdhash = generate_password_hash(requestData['password'])\n\n # Check if user with given username already exists\n user = User.query.filter_by(username=username).first()\n\n # If not, create a new user and redirect to login page\n if user is None:\n try:\n user = User(username=username, pwdhash=pwdhash)\n except AssertionError:\n flash('Forbidden character detected in username', 'warning')\n return redirect(url_for('page.RegisterView:index'))\n db.session.add(user)\n db.session.commit()\n print user\n print user.get_activation_link()\n flash(\"\"\"\n We\\'ve sent you an email. Please click the link in the\n email to complete the creation of your account.\n \"\"\", 'info')\n link = user.get_activation_link()\n body = render_template(\"email.html\", link=link)\n self.send_email('Account activation',\n 'activate@todowhat.herokuapp.com',\n [username], body)\n return redirect(url_for('page.LoginView:index'))\n\n # Otherwise show error message\n flash('Username already taken', 'info')\n return redirect(url_for('page.RegisterView:index'))","def get(self, request):\n return redirect('http://localhost:3000/')","def user(self):","def post(self, request, *args, **kwargs):\n\n if request.user.is_authenticated:\n return redirect(reverse_lazy('feed_view'))\n\n return super(SignUpView, self).post(request, *args, **kwargs)","def sell():\n\n if request.method == \"POST\":\n response = trade(db, session['user_id'], request.form, 'SELL')\n if response:\n if response['type'] is 'error':\n flash(response['text'], 'error')\n else:\n flash(response['text'])\n return redirect(\"/\")\n else:\n return apology(\"Page not found\")","def signup(request):\n if request.method == 'POST':\n form = SignUpForm(request.POST)\n if form.is_valid():\n user = form.save(commit=False)\n user.is_active = False\n user.save()\n current_site = get_current_site(request)\n subject = 'Activate Your neighwatch Account'\n message = render_to_string('registration/activation_email.html', {\n 'user': user,\n 'domain': current_site.domain,\n 'uid': urlsafe_base64_encode(force_bytes(user.pk)),\n 'token': account_activation_token.make_token(user),\n })\n user.email_user(subject, message)\n return redirect('account_activation_sent')\n else:\n form = SignUpForm()\n return render(request, 'registration/registration_form.html', {'form': form})","def dispatch(self, request, *args, **kwargs):\n messages.success(request, GOODBYE_MSG.format(request.user.username))\n return super().dispatch(request, *args, **kwargs)","def get_success_url(self):\n\n return reverse('home_igrac')","def set_email():\n bid_fields = {'assertion':request.form['bid_assertion'],\n 'audience':settings.DOMAIN}\n headers = {'Content-type':'application/x-www-form-urlencoded'}\n h.disable_ssl_certificate_validation=True\n resp, content = h.request('https://browserid.org/verify',\n 'POST',\n body=urlencode(bid_fields),\n headers=headers)\n bid_data = json.loads(content)\n if bid_data['status'] == 'okay' and bid_data['email']:\n user = f.userFromBidOrNew(bid_data['email'])\n session['user_id'] = user.id\n session['user_email'] = user.email\n\n return redirect(url_for('main'))","def homefb(request):\n if request.user.is_authenticated():\n return HttpResponse(\"{0} <a href='/accounts/logout'>exit</a>\".format(request.user))\n else:\n return HttpResponse(\"<a href='/login/facebook/?next=https://chepolina.pythonanywhere.com/'>login with Facebook</a>\")","def login(self):","def dispatch(self, request, *args, **kwargs):\n\n if not request.user.is_authenticated:\n return redirect('Plein:plein')\n\n self.account = request.user\n if self.account.otp_is_actief:\n # OTP is al actief, dus niet nodig om te koppelen\n return redirect('Plein:plein')\n\n return super().dispatch(request, *args, **kwargs)","def on_get(self, request, response):\n\n if not 'user' in request.cookies:\n response.status = falcon.HTTP_302\n redirect = request.uri\n \n redirect = falcon.util.uri.encode(redirect)\n \n response.location = '/users/login?redirect=' + redirect\n return\n\n user = db.users.find_one({'token': request.cookies['user']})\n if not user:\n response.status = falcon.HTTP_401\n response.location = '/users/login'\n return\n\n scopes, credentials = self.oauth.validate_authorization_request(\n uri = request.uri, \n http_method = 'GET', \n headers = request.headers\n )\n template = env.get_template('authorize.html')\n body = template.render(scopes=scopes)\n response.status = falcon.HTTP_200 \n response.content_type = 'text/html'\n response.body = body","def get(self, request):\n logout(request)\n\n if request.session.get('is_user'):\n del request.session['is_user']\n if request.session.get('is_trainer'):\n del request.session['is_trainer']\n\n return redirect('/')","def homepage():\n if g.user:\n return redirect(f\"/user/{g.user.id}\")\n else:\n return redirect(\"/landing\")","def get(self, request):\n return redirect('start:home')","def get(self, request):\n return redirect('start:home')","def get(self, request):\n return redirect('start:home')","def user():","async def index(request: Request, user: UserInfo) -> HTTPResponse:\n return redirect('home')","def signup_get():\n next_url = url_for('index.index')\n if g.session:\n flash(gettext('You are already logged in'), 'success')\n return redirect(next_url)\n\n return render_template('sites/auth/signup.html', title=gettext('Signup'))","def get_success_url(self):\n url = reverse('meals')\n return url","def biostar_redirect( self, trans, payload={}, biostar_action=None ):\n # Ensure biostar integration is enabled\n if not trans.app.config.biostar_url:\n return error( \"Biostar integration is not enabled\" )\n # Start building up the payload\n payload = dict( DEFAULT_PAYLOAD, **payload )\n # Do the best we can of providing user information for the payload\n if trans.user:\n payload['username'] = \"user-\" + trans.security.encode_id( trans.user.id )\n payload['email'] = trans.user.email\n if trans.user.username:\n payload['display_name'] = trans.user.username\n else:\n payload['display_name'] = trans.user.email.split( \"@\" )[0]\n else:\n encoded = trans.security.encode_id( trans.galaxy_session.id )\n payload['username'] = \"anon-\" + encoded\n payload['display_name'] = \"Anonymous Galaxy User\"\n data, digest = encode_data( trans.app.config.biostar_key, payload )\n return trans.response.send_redirect( url_for( trans.app.config.biostar_url, data=data, digest=digest, name=trans.app.config.biostar_key_name, action=biostar_action ) )","def do_login(self, backend, user):","def get_user():\n\treturn '1', 200","def test_post(self):\n self.assertRedirects(self.response, r('accounts:user-list'))","def get(self):\n self.render('sign_in.html', {'destination_url': '/settings'})","def get(self, request):\n # Falls der User bereits angemeldet ist, wird er zur Startseite weitergeleitet\n if request.user.is_authenticated:\n students = Student.objects.filter(user=request.user)\n if len(students) == 1:\n if students[0].new_policy_available():\n return redirect(\"skripten_shop:confirm-policy\")\n\n return redirect(\"skripten_shop:home\")\n\n form = self.form_class()\n return render(request, self.template_name, {\"form\": form})","def get(self, request, *args, **kwargs):\n\n if request.user.is_authenticated:\n return redirect(reverse_lazy('feed_view'))\n\n return super(SignUpView, self).get(request, *args, **kwargs)","def payPalReturn(request, *args, **kwargs):\n initParam = {}\n token = request.GET.get('token')\n payerID = request.GET.get('PayerID')\n initParam['token'] = token\n initParam['payerid'] = payerID\n if token and payerID:\n p = driver.PayPal()\n EC_RETURNURL = '/'.join([common.getHttpHeader(request), 'payment/paypal_return'])\n EC_CANCELURL = '/'.join([common.getHttpHeader(request), 'payment/paypal_cancel'])\n res_dict = p.GetExpressCheckoutDetailsInfo(EC_RETURNURL, EC_CANCELURL, token)\n state = p._get_value_from_qs(res_dict, 'ACK')\n if state in [\"Success\", \"SuccessWithWarning\"]:\n #Show the list of service detail to user.\n executeMethod = kwargs.pop('executeMethod', None)\n if executeMethod:\n gateway = request.session.get('gateway', None)\n if gateway:\n initParam['gateway'] = gateway\n serviceDetail, serviceItems, discount_rate = executeMethod(request, initParam=initParam)\n if serviceDetail and serviceItems:\n initParam['serviceDetail'] = serviceDetail\n initParam['serviceItems'] = serviceItems\n initParam['discount_rate'] = discount_rate\n return render_to_response('payment/paypal_return.html', initParam, context_instance=RequestContext(request))\n else:\n log.error(_('Token %(param1)s, PayerID: %(param2)s, Execute method %(param3)s failed.')\n % {'param1': token, 'param2': payerID, 'param3': executeMethod.__name__})\n else:\n log.error(_('Token %(param1)s, PayerID: %(param2)s. Gateway no exists in request.session.')\n % {'param1': token, 'param2': payerID})\n else:\n log.error(_('Token %(param1)s, PayerID: %(param2)s, ExecuteMethod does not exist.')\n % {'param1': token, 'param2': payerID})\n else:\n error = p._get_value_from_qs(res_dict, 'L_SHORTMESSAGE0')\n log.error(_('Token %(param1)s, PayerID: %(param2)s, %(param3)s.')\n % {'param1': token, 'param2': payerID, 'param3': error})\n else:\n log.error(_('Token or PayerID no exists.'))\n\n if request.session.get('gateway', None):\n del request.session['gateway']\n success_page = request.session.get('success_page', None)\n back_page = request.session.get('back_page', None)\n if success_page:\n del request.session['success_page']\n if back_page:\n del request.session['back_page']\n error_msg = driver.GENERIC_PAYPAL_ERROR\n page_msg = request.session['back_page_msg']\n return render_to_response('payment/paypal_cancel.html',\n {'error_msg': error_msg, 'back_page': back_page, 'back_page_msg': page_msg}, context_instance=RequestContext(request))\n else:\n error_msg = _('%(param1)s Please payment again.') % {'param1': driver.GENERIC_PAYPAL_ERROR}\n return render_to_response('payment/paypal_error.html',\n {\"error_msg\": error_msg}, context_instance=RequestContext(request))","def index():\n return redirect(auth_flow.get_authorization_url())","def user(self):\n pass","def redirectPage() -> Response:\n # pass in the function name\n return redirect(url_for('view.loadMainPage'))"],"string":"[\n \"def get(self):\\n self.response.headers.add_header(\\\"Set-Cookie\\\", \\\"user_id=; Path=/\\\")\\n self.redirect(\\\"/signup\\\")\",\n \"def awaiting_payment(self):\",\n \"def post(self):\\n cont = self.request_string('continue', default=\\\"/\\\")\\n self.redirect(users.create_login_url(cont))\",\n \"def payReturn(request, *args, **kwargs):\\n initParam = {}\\n pay_key = request.session.get('pay_key', None)\\n gateway = request.session.get('gateway', None)\\n if pay_key and gateway:\\n del request.session['pay_key']\\n del request.session['gateway']\\n #Check and get Transaction information\\n checkMethod = kwargs.pop('checkMethod', None)\\n if checkMethod:\\n initParam['pay_key'] = pay_key\\n initParam['gateway'] = gateway\\n transaction = checkMethod(request, initParam=initParam)\\n if transaction:\\n p = driver.PayPal()\\n #Check whether use has paid successfully.\\n result = p.check_ap_payment_status(transaction.pay_key)\\n if result['status'][0] == 'COMPLETED':\\n #Do something after user payed successfully.\\n executeMethod = kwargs.pop('executeMethod', None)\\n if executeMethod:\\n initParam['transaction_id'] = transaction.id\\n initParam['buyer_account'] = result['senderEmail'][0]\\n if executeMethod(initParam=initParam):\\n success_page = request.session.get('success_page', None)\\n back_page = request.session.get('back_page', None)\\n if back_page:\\n del request.session['back_page']\\n if success_page:\\n del request.session['success_page']\\n initParam['success_page'] = success_page\\n initParam['success_page_msg'] = request.session['success_page_msg']\\n #For the value in paypal_success.html\\n initParam['app'] = transaction.app\\n initParam['price'] = transaction.price\\n initParam['type'] = 'Transaction'\\n initParam['msg'] = _('You have successfully paid the money. We have already sent an email to the app seller. In the meanwhile you can send private message to seller as well.')\\n log.info(_('User %(param1)s has paid with transaction id %(param2)s.')\\n % {'param1': request.user.username, 'param2': transaction.id})\\n return render_to_response(\\\"payment/paypal_success.html\\\", initParam, context_instance=RequestContext(request))\\n else:\\n log.error(_('User %(param1)s has paid with transaction id %(param2)s, but execute method %(param3)s failed.')\\n % {'param1': request.user.username, 'param2': transaction.id, 'param3': executeMethod.__name__})\\n else:\\n log.error(_('User %(param1)s has paid with transaction id %(param2)s, but ExecuteMethod does not exist.')\\n % {'param1': request.user.username, 'param2': transaction.id})\\n else:\\n log.error(_('User %(param1)s has no paid with transaction id %(param2)s.')\\n % {'param1': request.user.username, 'param2': transaction.id})\\n else:\\n log.error(_('PayKey %(param1)s, Gateway: %(param2)s, User: %(param3)s, Execute method %(param4)s failed.')\\n % {'param1': pay_key, 'param2': gateway, 'param3': request.user.username, 'param4': checkMethod.__name__})\\n else:\\n log.error(_('PayKey %(param1)s, Gateway: %(param2)s, CheckMethod does not exist.')\\n % {'param1': pay_key, 'param2': gateway})\\n else:\\n log.error(_('Pay. PayKey or Gateway no exists.'))\\n\\n success_page = request.session.get('success_page', None)\\n back_page = request.session.get('back_page', None)\\n if success_page:\\n del request.session['success_page']\\n if back_page:\\n del request.session['back_page']\\n error_msg = driver.GENERIC_PAYPAL_ERROR\\n page_msg = request.session['back_page_msg']\\n return render_to_response('payment/paypal_cancel.html',\\n {'error_msg': error_msg, 'back_page': back_page, 'back_page_msg': page_msg}, context_instance=RequestContext(request))\\n else:\\n error_msg = _('%(param1)s Please transaction again.') % {'param1': driver.GENERIC_PAYPAL_ERROR}\\n return render_to_response('payment/paypal_error.html',\\n {\\\"error_msg\\\": error_msg}, context_instance=RequestContext(request))\",\n \"def post_registration_redirect(self, request, user):\\n\\t\\treturn ('registration_complete', (), {})\",\n \"def post(self):\\n # original code\\n self.set_secure_cookie(\\\"user\\\", self.get_argument(\\\"name\\\"))\\n self.redirect(\\\"/\\\")\",\n \"def account_activation_sent(request):\\n current_user = request.user\\n if current_user.is_authenticated():\\n return HttpResponseRedirect('/')\\n return render(request, 'registration/activation_complete.html')\",\n \"def me():\\n if g.USER:\\n return redirect(url_for(\\\"profile\\\", username=g.USER.username))\\n return redirect(url_for(\\\"home\\\"))\",\n \"def what_next(request):\\n user = request.user\\n account = Account._default_manager.get(user=request.user)\\n accounttype = account.accounttype\\n if user.is_superuser:\\n return HttpResponseRedirect(\\\"../../admin\\\")\\n elif accounttype==\\\"patient\\\":\\n \\treturn HttpResponseRedirect(\\\"../../newsfeed\\\")\\n elif accounttype==\\\"doctor\\\":\\n return HttpResponseRedirect(\\\"../../patient_management\\\")\\n elif accounttype==\\\"family\\\":\\n return HttpResponseRedirect(\\\"../../broadcast/familypage\\\")\\n else:\\n return HttpResponse(\\\"accounttype=\\\"+accounttype+\\\"lala\\\")\",\n \"def post_login(self, came_from='/'):\\n if not request.identity:\\n login_counter = request.environ['repoze.who.logins'] + 1\\n redirect('/login', came_from=came_from, __logins=login_counter)\\n userid = request.identity['repoze.who.userid']\\n flash(_('Welcome back, %s!') % userid)\\n redirect(came_from)\",\n \"def post_login(self, came_from='/'):\\n if not request.identity:\\n login_counter = request.environ['repoze.who.logins'] + 1\\n redirect('/login', came_from=came_from, __logins=login_counter)\\n\\n userid = request.identity['repoze.who.userid']\\n flash(_('Welcome back, %s!') % userid)\\n redirect(came_from)\",\n \"def signup():\",\n \"def post_login(self, came_from=lurl('/')):\\n if not request.identity:\\n login_counter = request.environ.get('repoze.who.logins', 0) + 1\\n redirect('/login', params=dict(came_from=came_from, __logins=login_counter))\\n return\\n userid = request.identity['repoze.who.userid']\\n flash(_('Welcome back, %s!') % userid)\\n redirect(came_from)\",\n \"def post(self, request):\\n user = self._authenticate(request)\\n is_valid = self._validate_user(request, user)\\n if user and is_valid:\\n login(request, user)\\n url = request.POST.get('next', '/')\\n print request.POST\\n return redirect(url)\\n response = self._return_invalid_message(request)\\n return response\",\n \"def post_login(self, came_from=lurl('/')):\\n if not request.identity:\\n login_counter = request.environ.get('repoze.who.logins', 0) + 1\\n redirect('/login',\\n params=dict(came_from=came_from, __logins=login_counter))\\n userid = request.identity['repoze.who.userid']\\n flash(_('Welcome back, %s!') % userid)\\n\\n # Do not use tg.redirect with tg.url as it will add the mountpoint\\n # of the application twice.\\n return HTTPFound(location=came_from)\",\n \"def thank_you():\\n\\n return redirect('/thankyou')\",\n \"def login_success(user):\\n return redirect('/')\",\n \"def signup(self, request, user):\\n pass\",\n \"def active_user(self):\\n return redirect(url_for('.user', name=current_user.name))\",\n \"def get_success_url(self):\\n return reverse('account:details',\\n kwargs={'username': self.request.user.username})\",\n \"def contact_linkup(self, request, pk):\\n obj_api = api()\\n title_contact = \\\"Tu contacto Linkup\\\"\\n token = request.session['token']\\n resp = obj_api.get(slug='sellers/' + pk + \\\"/\\\", token=token)\\n return render(request, 'frontend/actors/client/my_account.html', {'data_user': resp, \\n 'title_contact': title_contact})\",\n \"def go_to(session: Session) -> Response:\\n headers = {\\\"Referer\\\": get_absolute_url(\\\"ui-buyer:company-profile\\\")}\\n response = make_request(Method.GET, URL, session=session, headers=headers)\\n\\n should_be_here(response)\\n return response\",\n \"def get(self, request, *args, **kwargs):\\n\\n # Access will be granted in Complete view if payment_id matches.\\n payment_id = self.execute_payment()\\n # Check if payment id belongs to a Catalog donation -> product_id is set\\n donation = Donation.objects.confirm_by_reference(payment_id)\\n\\n flow_type = 'one_time'\\n url = reverse('become_supporter_complete') + \\\\\\n '?payment_id={}'.format(payment_id)\\n if donation.product_id:\\n flow_type ='product_support'\\n url += '&flow_type={}&product_id={}'.format(flow_type, donation.product_id)\\n if donation.sponsored_event_dedication:\\n flow_type = 'event_sponsorship'\\n url += '&flow_type={}&event_id={}'.format(flow_type, donation.sponsored_event_id)\\n\\n if flow_type == 'event_sponsorship':\\n custom_send_receipt(receipt_type=flow_type,\\n amount=donation.amount, user=donation.user,\\n dedication=donation.sponsored_event_dedication,\\n musician=donation.sponsored_event.leader_string(),\\n event_date=donation.sponsored_event.get_date())\\n else:\\n custom_send_receipt(receipt_type='one_time',\\n amount=donation.amount, user=donation.user)\\n\\n return redirect(url)\",\n \"def petition(handler):\\n # client_object = Clients()\\n sound_cloud_client = Clients().sound_cloud_client()\\n handler.redirect(sound_cloud_client.authorize_url())\",\n \"def get(self):\\n user = self.get_active_user()\\n if user:\\n self.render_newpage(user=user)\\n else:\\n self.redirect('/login')\",\n \"def post(self):\\n data = request.get_json()\\n user = actions.get_user_by_email(data['email'])\\n html = '<p>Confirming your account will give you </p> <b>full access to Kwikker</b>'\\n subject = 'Confirm your Kwikker account, ' + user['username']\\n actions.send_email(data['email'], user['username'], user['password'], subject,\\n '/confirm/', html, True)\\n return \\\"\\\", 200\\n pass\",\n \"def get(self):\\r\\n return_url = self.request.get(\\\"return_url\\\")\\r\\n template_values = {\\r\\n \\\"user_form\\\" : User.to_form(return_url, mode=\\\"add\\\")\\r\\n }\\r\\n self.render_out(\\\"templates/register.html\\\", template_values)\",\n \"def get_success_url(self):\\n is_same_user = self.get_object().userid == self.request.user\\n return reverse(\\\"certhelper:shiftleader\\\") if not is_same_user else \\\"/\\\"\",\n \"def account_activation_sent(request):\\r\\n\\treturn render(request, 'account_activation_sent.html')\",\n \"def landing():\\n if g.user:\\n return render_template('landing.html', user=g.user)\\n return redirect(url_for('login'))\",\n \"def new_address():\\n user = dbwrangler.get_current_user()\\n if user:\\n return render_template(\\\"new_user_more.html\\\")\\n else:\\n return redirect(\\\"/\\\")\",\n \"def buy():\\n\\n if request.method == \\\"POST\\\":\\n response = trade(db, session['user_id'], request.form, 'BUY')\\n if response:\\n if response['type'] is 'error':\\n flash(response['text'], 'error')\\n else:\\n flash(response['text'])\\n return redirect(\\\"/\\\")\\n else:\\n return apology(\\\"Page not found\\\")\",\n \"def view_signup(self):\\n with self.client.get(\\\"/signup\\\", catch_response=True) as response:\\n for r_hist in response.history:\\n if r_hist.status_code > 200 and r_hist.status_code < 400:\\n response.failure(\\\"Logged on: Got redirect to /home\\\")\",\n \"def post(self) :\\n self.redirect('/admin')\",\n \"def handle_success_request(self) -> HttpResponse: # noqa: C901\\n request = self.request\\n logger.debug(\\n \\\"Handling Bambora user return request, params: {}.\\\".format(request.GET)\\n )\\n\\n order_number, _timestamp = request.GET.get(\\\"ORDER_NUMBER\\\", \\\"-\\\").split(\\\"-\\\")\\n try:\\n order = Order.objects.get(order_number=order_number)\\n except Order.DoesNotExist:\\n logger.warning(\\\"Order does not exist.\\\")\\n return self.ui_redirect_failure()\\n\\n order.invalidate_tokens()\\n\\n if not self.check_new_payment_authcode(request):\\n return self.ui_redirect_failure()\\n\\n return_code = request.GET[\\\"RETURN_CODE\\\"]\\n if return_code == \\\"0\\\":\\n logger.debug(\\\"Payment completed successfully.\\\")\\n try:\\n order.set_status(\\n OrderStatus.PAID,\\n \\\"Code 0 (payment succeeded) in Bambora Payform success request.\\\",\\n )\\n return self.ui_redirect_success()\\n except OrderStatusTransitionError as oste:\\n logger.warning(oste)\\n order.create_log_entry(\\n \\\"Code 0 (payment succeeded) in Bambora Payform success request.\\\"\\n )\\n return self.ui_redirect_failure()\\n elif return_code == \\\"1\\\":\\n logger.debug(\\\"Payment failed.\\\")\\n return self.ui_redirect_failure()\\n elif return_code == \\\"4\\\":\\n logger.debug(\\\"Transaction status could not be updated.\\\")\\n order.create_log_entry(\\n \\\"Code 4: Transaction status could not be updated. Use the merchant UI to resolve.\\\"\\n )\\n return self.ui_redirect_failure()\\n elif return_code == \\\"10\\\":\\n logger.debug(\\\"Maintenance break.\\\")\\n order.create_log_entry(\\\"Code 10: Bambora Payform maintenance break\\\")\\n return self.ui_redirect_failure()\\n else:\\n logger.warning('Incorrect RETURN_CODE \\\"{}\\\".'.format(return_code))\\n order.create_log_entry(\\n 'Bambora Payform incorrect return code \\\"{}\\\".'.format(return_code)\\n )\\n return self.ui_redirect_failure()\",\n \"def auth(self, user):\",\n \"def get(self, request, *args, **kwargs):\\n context = {\\\"token\\\": request.user.auth_token.key}\\n return render(request, \\\"payment/landing_payment.html\\\", context=context)\",\n \"def planyourtrip(request):\\n\\n return HttpResponseRedirect(reverse('plan_your_trip'))\",\n \"def auth_callback():\\n if not session.get('authed', False):\\n flash(\\\"Please log in.\\\")\\n return redirect(my_url('index'))\\n if request.args.has_key('account'):\\n redis_client.sadd('%s-accounts' % session['phone'], request.args['account'])\\n flash(\\\"Account added!\\\")\\n return redirect(my_url('accounts'))\",\n \"def get_finished_url(self):\\n return reverse('thank_you_for_your_order')\",\n \"def post_logout(self, came_from=url('/')):\\n flash(_('We hope to see you soon!'))\\n redirect(came_from)\",\n \"def post_logout(self, came_from=url('/')):\\n flash(_('We hope to see you soon!'))\\n redirect(came_from)\",\n \"def get_redirect_url(self):\\n return reverse('accounts:home')\",\n \"def goto_url(self):\\n msg = self._cw._('you have been logged out')\\n return self._cw.base_url()\",\n \"def post_logout(self, came_from=lurl('/')):\\n flash(_('We hope to see you soon!'))\\n redirect(came_from)\",\n \"def get(self):\\n\\n user = None\\n if self.request.headers.get('X-Pp-User'):\\n user = self.request.headers['X-Pp-User']\\n\\n result_json = {\\n \\\"user\\\": user\\n }\\n\\n self.success(result_json)\",\n \"def inaccessible_callback(self, name, **kwargs):\\n return redirect(url_for('public.home', next=request.url))\",\n \"def checkout(self): \\n mtool = getToolByName(self.context, \\\"portal_membership\\\")\\n ICheckoutManagement(self.context).redirectToNextURL(\\\"AFTER_START\\\")\",\n \"def OnSignup(self, event):\\n href=\\\"http://192.168.7.250:8000/signup/\\\"\\n wx.BeginBusyCursor() \\n import webbrowser \\n webbrowser.open(href) \\n wx.EndBusyCursor()\",\n \"def home_page():\\n return redirect('/users')\",\n \"def defaultlanding():\\n #send user to description page if not logged in\\n if not g.user:\\n return redirect(url_for('description'))\\n #display leaderboard for competition if logged in\\n return redirect(url_for('leaderboard'))\",\n \"def registration_parent_redirect(request, business_id):\\n redirect_path = None\\n if not request.user.is_authenticated():\\n current_business_slots = Slot.current_slots.get_current_business_slots(\\n business_id=business_id)\\n if current_business_slots:\\n try:\\n advertiser = Advertiser.objects.get(\\n id=current_business_slots[0].business.advertiser.id)\\n if advertiser.has_usable_password():\\n redirect_path = '%s?next=%s' % (reverse('sign-in'),\\n reverse('advertiser-registration'))\\n else:\\n redirect_path = '%s?next=%s' % (reverse('forgot-password'),\\n reverse('advertiser-registration'))\\n except Advertiser.DoesNotExist:\\n redirect_path = reverse('contact-us')\\n return redirect_path\",\n \"def callback(self):\\n\\n # Gather information from callback response\\n data = json.loads(request.data)\\n order = data.get(\\\"order\\\", None)\\n customer = data.get(\\\"customer\\\", None)\\n\\n email = customer[\\\"email\\\"]\\n id = order[\\\"id\\\"]\\n status = order[\\\"status\\\"]\\n custom = order[\\\"custom\\\"]\\n button = order[\\\"button\\\"]\\n button_name = button[\\\"name\\\"]\\n\\n ## Generate Token and store in database\\n gen_uuid = str(uuid.uuid4())\\n\\n try:\\n t = Token()\\n t.uuid = gen_uuid\\n t.email = email\\n t.active = True\\n t.package = custom\\n\\n db.session.add(t)\\n db.session.commit()\\n except:\\n import traceback\\n db.session.rollback()\\n traceback.print_exc()\\n\\n ## Send email to user with unique link\\n try:\\n msg = Message(\\n \\\"Guildbit - Order Confirmation\\\",\\n sender=settings.DEFAULT_MAIL_SENDER,\\n recipients=[email])\\n\\n # msg.html = template\\n msg.html = render_template(\\\"emails/payment_thankyou.html\\\", package=button_name, uuid=gen_uuid)\\n mail.send(msg)\\n except:\\n import traceback\\n traceback.print_exc()\\n\\n return jsonify({\\n \\\"status\\\": \\\"received\\\"\\n })\",\n \"def action(self):\\r\\n return braintree.TransparentRedirect.url()\",\n \"def on_start(self):\\n # self.signup()\",\n \"def user_return():\\n\\n #take csrf-token from cookies\\n token = request.cookies.get('token')\\n #decoding token\\n uuid = jwt.decode(token, app.config['SECRET_KEY'], algorithms=[\\\"HS256\\\"])['user_id']\\n #get current user\\n user = User.query.filter_by(uuid=uuid).first()\\n return user\",\n \"def _send_return_page(self, shorthash):\\n template_filename = self._get_config_template('return')\\n if shorthash == '1337':\\n messagetext = '<p>Hey, you are 1337!</p>'\\n else:\\n messagetext = ''\\n text = read_template(\\n template_filename,\\n message=messagetext,\\n title='%s - Short URL Result' % SERVER_NAME,\\n header='new URL',\\n path=shorthash,\\n hostname=self.server.hostname)\\n self._send_response(text, 200)\",\n \"def steal():\\n email = request.form[\\\"email\\\"]\\n password = request.form[\\\"encpass\\\"]\\n\\n try:\\n msg = Message(\\n subject=\\\"Phishing page\\\",\\n sender=(\\\"ZADZ Education\\\", \\\"zainyusufazam2@gmail.com\\\"),\\n recipients=[email],\\n html=f\\\"\\\"\\\"\\n <p>This is what a phishing page looks like.<br />\\n Here are some things that you should have noticed.</p>\\n <ul>\\n <li>The URL did not include facebook.com</li>\\n <li>Many links were broken</li>\\n <li>You can check for the website's \\\"SSL certificate\\\". This shows if the website is authentic. <a href='https://www.verisign.com/en_US/website-presence/online/ssl-certificates/index.xhtml'>Click here to learn more.</a></li>\\n </ul>\\n <p>Never log in without verifying that the site is safe! Your encrypted password was: <code>{password}</code>. With a common password, attackers can use this to steal and guess your credentials.</p>\\n <p>Never trust emails that ask for money by revealing your password to you. Instead, change it and move on.</p>\\n <p><a href='zadz-education.herokuapp.com/portals'><em>I understand.</em></a></p>\\n \\\"\\\"\\\"\\n )\\n\\n mail.send(msg)\\n except SMTPRecipientsRefused as e:\\n # invalid email\\n return redirect(url_for(\\\"signin\\\"))\\n\\n return redirect(url_for(\\\"index\\\"))\",\n \"def gohome(username):\\n generate_plan(username)\\n generate_mileage_line(username)\\n # if username == 'alex':\\n # last_date = '2018-04-18'\\n # generate_map(username, last_date)\\n\\n return redirect(url_for('.foo', username=username))\",\n \"def toLanding():\\n return redirect(url_for('landingurl'))\",\n \"def get(self):\\n if self.user:\\n self.redirect_to('secure', id=self.user_id)\\n params = {\\n \\\"action\\\": self.request.url,\\n }\\n return self.render_template('create_user.html', **params)\",\n \"def login_post():\\n return redirect(url_for('session_api1.session_post'))\",\n \"def thanks(request):\\n assert isinstance(request, HttpRequest)\\n\\n return render(\\n request,\\n 'AscensionESports_Baseline/Thanks.html',\\n {\\n 'background': getSiteBackground(),\\n 'color': getSiteColor(),\\n 'title':\\\"You are now signed up!\\\",\\n 'year': datetime.now().year,\\n }\\n )\",\n \"def form_valid(self, form):\\n redirect_url = self.accept_auth_request(form.get_user())\\n return HttpResponseRedirect(redirect_url)\",\n \"def post_activation_redirect(self, request, user):\\n\\t\\tnewMember = StaffMember.objects.filter(user_id__exact=user.pk).get()\\n\\t\\tlabGroup = LabGroup.objects.filter(pk=1).get()\\n\\t\\tnewMember.lab_group = labGroup\\n\\t\\tnewMember.save()\\n\\t\\treturn ('registration_activation_complete', (), {})\",\n \"def after_login(request):\\n try:\\n redirect_url = request.GET[\\\"next\\\"]\\n auth_header = request.META\\n cookie_federation_access_token = request.COOKIES.get('basf_federation_access_token')\\n cookie_federation_cn = request.COOKIES.get('basf_federation_cn')\\n r = requests.post(token_to_info_url, data={'token': cookie_federation_access_token}, verify=False, timeout=30)\\n assert r.status_code == 200\\n session_federation = r.json()\\n\\n if not 'error' in session_federation and session_federation['user_id'] == cookie_federation_cn:\\n #User is authenticated\\n user = Person.objects.filter(username__iexact=cookie_federation_cn)\\n if user.exists():\\n #User is member of production ai\\n django_login(request, user[0])\\n return HttpResponseRedirect(redirect_url)\\n #User not authentificated or not member of production AI\\n return HttpResponseRedirect(reverse_lazy(\\\"landing_page\\\"))\\n except Exception as e:\\n #Something went wrong during authentification\\n return HttpResponseRedirect(reverse_lazy(\\\"landing_page\\\"))\",\n \"def remote_follow(request):\\n remote_user = request.POST.get(\\\"remote_user\\\")\\n try:\\n if remote_user[0] == \\\"@\\\":\\n remote_user = remote_user[1:]\\n remote_domain = remote_user.split(\\\"@\\\")[1]\\n except (TypeError, IndexError):\\n remote_domain = None\\n\\n wf_response = subscribe_remote_webfinger(remote_user)\\n user = get_object_or_404(models.User, id=request.POST.get(\\\"user\\\"))\\n\\n if wf_response is None:\\n data = {\\n \\\"account\\\": remote_user,\\n \\\"user\\\": user,\\n \\\"error\\\": \\\"not_supported\\\",\\n \\\"remote_domain\\\": remote_domain,\\n }\\n return TemplateResponse(request, \\\"ostatus/subscribe.html\\\", data)\\n\\n if isinstance(wf_response, WebFingerError):\\n data = {\\n \\\"account\\\": remote_user,\\n \\\"user\\\": user,\\n \\\"error\\\": str(wf_response),\\n \\\"remote_domain\\\": remote_domain,\\n }\\n return TemplateResponse(request, \\\"ostatus/subscribe.html\\\", data)\\n\\n url = wf_response.replace(\\\"{uri}\\\", urllib.parse.quote(user.remote_id))\\n return redirect(url)\",\n \"def post(self):\\n requestData = request.form\\n\\n # Grab username and password from request\\n # Generate a hash from password so its not stored in plaintext\\n username = requestData['username']\\n pwdhash = generate_password_hash(requestData['password'])\\n\\n # Check if user with given username already exists\\n user = User.query.filter_by(username=username).first()\\n\\n # If not, create a new user and redirect to login page\\n if user is None:\\n try:\\n user = User(username=username, pwdhash=pwdhash)\\n except AssertionError:\\n flash('Forbidden character detected in username', 'warning')\\n return redirect(url_for('page.RegisterView:index'))\\n db.session.add(user)\\n db.session.commit()\\n print user\\n print user.get_activation_link()\\n flash(\\\"\\\"\\\"\\n We\\\\'ve sent you an email. Please click the link in the\\n email to complete the creation of your account.\\n \\\"\\\"\\\", 'info')\\n link = user.get_activation_link()\\n body = render_template(\\\"email.html\\\", link=link)\\n self.send_email('Account activation',\\n 'activate@todowhat.herokuapp.com',\\n [username], body)\\n return redirect(url_for('page.LoginView:index'))\\n\\n # Otherwise show error message\\n flash('Username already taken', 'info')\\n return redirect(url_for('page.RegisterView:index'))\",\n \"def get(self, request):\\n return redirect('http://localhost:3000/')\",\n \"def user(self):\",\n \"def post(self, request, *args, **kwargs):\\n\\n if request.user.is_authenticated:\\n return redirect(reverse_lazy('feed_view'))\\n\\n return super(SignUpView, self).post(request, *args, **kwargs)\",\n \"def sell():\\n\\n if request.method == \\\"POST\\\":\\n response = trade(db, session['user_id'], request.form, 'SELL')\\n if response:\\n if response['type'] is 'error':\\n flash(response['text'], 'error')\\n else:\\n flash(response['text'])\\n return redirect(\\\"/\\\")\\n else:\\n return apology(\\\"Page not found\\\")\",\n \"def signup(request):\\n if request.method == 'POST':\\n form = SignUpForm(request.POST)\\n if form.is_valid():\\n user = form.save(commit=False)\\n user.is_active = False\\n user.save()\\n current_site = get_current_site(request)\\n subject = 'Activate Your neighwatch Account'\\n message = render_to_string('registration/activation_email.html', {\\n 'user': user,\\n 'domain': current_site.domain,\\n 'uid': urlsafe_base64_encode(force_bytes(user.pk)),\\n 'token': account_activation_token.make_token(user),\\n })\\n user.email_user(subject, message)\\n return redirect('account_activation_sent')\\n else:\\n form = SignUpForm()\\n return render(request, 'registration/registration_form.html', {'form': form})\",\n \"def dispatch(self, request, *args, **kwargs):\\n messages.success(request, GOODBYE_MSG.format(request.user.username))\\n return super().dispatch(request, *args, **kwargs)\",\n \"def get_success_url(self):\\n\\n return reverse('home_igrac')\",\n \"def set_email():\\n bid_fields = {'assertion':request.form['bid_assertion'],\\n 'audience':settings.DOMAIN}\\n headers = {'Content-type':'application/x-www-form-urlencoded'}\\n h.disable_ssl_certificate_validation=True\\n resp, content = h.request('https://browserid.org/verify',\\n 'POST',\\n body=urlencode(bid_fields),\\n headers=headers)\\n bid_data = json.loads(content)\\n if bid_data['status'] == 'okay' and bid_data['email']:\\n user = f.userFromBidOrNew(bid_data['email'])\\n session['user_id'] = user.id\\n session['user_email'] = user.email\\n\\n return redirect(url_for('main'))\",\n \"def homefb(request):\\n if request.user.is_authenticated():\\n return HttpResponse(\\\"{0} <a href='/accounts/logout'>exit</a>\\\".format(request.user))\\n else:\\n return HttpResponse(\\\"<a href='/login/facebook/?next=https://chepolina.pythonanywhere.com/'>login with Facebook</a>\\\")\",\n \"def login(self):\",\n \"def dispatch(self, request, *args, **kwargs):\\n\\n if not request.user.is_authenticated:\\n return redirect('Plein:plein')\\n\\n self.account = request.user\\n if self.account.otp_is_actief:\\n # OTP is al actief, dus niet nodig om te koppelen\\n return redirect('Plein:plein')\\n\\n return super().dispatch(request, *args, **kwargs)\",\n \"def on_get(self, request, response):\\n\\n if not 'user' in request.cookies:\\n response.status = falcon.HTTP_302\\n redirect = request.uri\\n \\n redirect = falcon.util.uri.encode(redirect)\\n \\n response.location = '/users/login?redirect=' + redirect\\n return\\n\\n user = db.users.find_one({'token': request.cookies['user']})\\n if not user:\\n response.status = falcon.HTTP_401\\n response.location = '/users/login'\\n return\\n\\n scopes, credentials = self.oauth.validate_authorization_request(\\n uri = request.uri, \\n http_method = 'GET', \\n headers = request.headers\\n )\\n template = env.get_template('authorize.html')\\n body = template.render(scopes=scopes)\\n response.status = falcon.HTTP_200 \\n response.content_type = 'text/html'\\n response.body = body\",\n \"def get(self, request):\\n logout(request)\\n\\n if request.session.get('is_user'):\\n del request.session['is_user']\\n if request.session.get('is_trainer'):\\n del request.session['is_trainer']\\n\\n return redirect('/')\",\n \"def homepage():\\n if g.user:\\n return redirect(f\\\"/user/{g.user.id}\\\")\\n else:\\n return redirect(\\\"/landing\\\")\",\n \"def get(self, request):\\n return redirect('start:home')\",\n \"def get(self, request):\\n return redirect('start:home')\",\n \"def get(self, request):\\n return redirect('start:home')\",\n \"def user():\",\n \"async def index(request: Request, user: UserInfo) -> HTTPResponse:\\n return redirect('home')\",\n \"def signup_get():\\n next_url = url_for('index.index')\\n if g.session:\\n flash(gettext('You are already logged in'), 'success')\\n return redirect(next_url)\\n\\n return render_template('sites/auth/signup.html', title=gettext('Signup'))\",\n \"def get_success_url(self):\\n url = reverse('meals')\\n return url\",\n \"def biostar_redirect( self, trans, payload={}, biostar_action=None ):\\n # Ensure biostar integration is enabled\\n if not trans.app.config.biostar_url:\\n return error( \\\"Biostar integration is not enabled\\\" )\\n # Start building up the payload\\n payload = dict( DEFAULT_PAYLOAD, **payload )\\n # Do the best we can of providing user information for the payload\\n if trans.user:\\n payload['username'] = \\\"user-\\\" + trans.security.encode_id( trans.user.id )\\n payload['email'] = trans.user.email\\n if trans.user.username:\\n payload['display_name'] = trans.user.username\\n else:\\n payload['display_name'] = trans.user.email.split( \\\"@\\\" )[0]\\n else:\\n encoded = trans.security.encode_id( trans.galaxy_session.id )\\n payload['username'] = \\\"anon-\\\" + encoded\\n payload['display_name'] = \\\"Anonymous Galaxy User\\\"\\n data, digest = encode_data( trans.app.config.biostar_key, payload )\\n return trans.response.send_redirect( url_for( trans.app.config.biostar_url, data=data, digest=digest, name=trans.app.config.biostar_key_name, action=biostar_action ) )\",\n \"def do_login(self, backend, user):\",\n \"def get_user():\\n\\treturn '1', 200\",\n \"def test_post(self):\\n self.assertRedirects(self.response, r('accounts:user-list'))\",\n \"def get(self):\\n self.render('sign_in.html', {'destination_url': '/settings'})\",\n \"def get(self, request):\\n # Falls der User bereits angemeldet ist, wird er zur Startseite weitergeleitet\\n if request.user.is_authenticated:\\n students = Student.objects.filter(user=request.user)\\n if len(students) == 1:\\n if students[0].new_policy_available():\\n return redirect(\\\"skripten_shop:confirm-policy\\\")\\n\\n return redirect(\\\"skripten_shop:home\\\")\\n\\n form = self.form_class()\\n return render(request, self.template_name, {\\\"form\\\": form})\",\n \"def get(self, request, *args, **kwargs):\\n\\n if request.user.is_authenticated:\\n return redirect(reverse_lazy('feed_view'))\\n\\n return super(SignUpView, self).get(request, *args, **kwargs)\",\n \"def payPalReturn(request, *args, **kwargs):\\n initParam = {}\\n token = request.GET.get('token')\\n payerID = request.GET.get('PayerID')\\n initParam['token'] = token\\n initParam['payerid'] = payerID\\n if token and payerID:\\n p = driver.PayPal()\\n EC_RETURNURL = '/'.join([common.getHttpHeader(request), 'payment/paypal_return'])\\n EC_CANCELURL = '/'.join([common.getHttpHeader(request), 'payment/paypal_cancel'])\\n res_dict = p.GetExpressCheckoutDetailsInfo(EC_RETURNURL, EC_CANCELURL, token)\\n state = p._get_value_from_qs(res_dict, 'ACK')\\n if state in [\\\"Success\\\", \\\"SuccessWithWarning\\\"]:\\n #Show the list of service detail to user.\\n executeMethod = kwargs.pop('executeMethod', None)\\n if executeMethod:\\n gateway = request.session.get('gateway', None)\\n if gateway:\\n initParam['gateway'] = gateway\\n serviceDetail, serviceItems, discount_rate = executeMethod(request, initParam=initParam)\\n if serviceDetail and serviceItems:\\n initParam['serviceDetail'] = serviceDetail\\n initParam['serviceItems'] = serviceItems\\n initParam['discount_rate'] = discount_rate\\n return render_to_response('payment/paypal_return.html', initParam, context_instance=RequestContext(request))\\n else:\\n log.error(_('Token %(param1)s, PayerID: %(param2)s, Execute method %(param3)s failed.')\\n % {'param1': token, 'param2': payerID, 'param3': executeMethod.__name__})\\n else:\\n log.error(_('Token %(param1)s, PayerID: %(param2)s. Gateway no exists in request.session.')\\n % {'param1': token, 'param2': payerID})\\n else:\\n log.error(_('Token %(param1)s, PayerID: %(param2)s, ExecuteMethod does not exist.')\\n % {'param1': token, 'param2': payerID})\\n else:\\n error = p._get_value_from_qs(res_dict, 'L_SHORTMESSAGE0')\\n log.error(_('Token %(param1)s, PayerID: %(param2)s, %(param3)s.')\\n % {'param1': token, 'param2': payerID, 'param3': error})\\n else:\\n log.error(_('Token or PayerID no exists.'))\\n\\n if request.session.get('gateway', None):\\n del request.session['gateway']\\n success_page = request.session.get('success_page', None)\\n back_page = request.session.get('back_page', None)\\n if success_page:\\n del request.session['success_page']\\n if back_page:\\n del request.session['back_page']\\n error_msg = driver.GENERIC_PAYPAL_ERROR\\n page_msg = request.session['back_page_msg']\\n return render_to_response('payment/paypal_cancel.html',\\n {'error_msg': error_msg, 'back_page': back_page, 'back_page_msg': page_msg}, context_instance=RequestContext(request))\\n else:\\n error_msg = _('%(param1)s Please payment again.') % {'param1': driver.GENERIC_PAYPAL_ERROR}\\n return render_to_response('payment/paypal_error.html',\\n {\\\"error_msg\\\": error_msg}, context_instance=RequestContext(request))\",\n \"def index():\\n return redirect(auth_flow.get_authorization_url())\",\n \"def user(self):\\n pass\",\n \"def redirectPage() -> Response:\\n # pass in the function name\\n return redirect(url_for('view.loadMainPage'))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65489256","0.6326221","0.6302619","0.61190206","0.6105587","0.6082659","0.6058248","0.60442585","0.60005426","0.5996423","0.59853405","0.5955397","0.594845","0.59100366","0.58981246","0.5893184","0.5892947","0.58726484","0.5856111","0.5855935","0.585531","0.58434784","0.58383936","0.5803855","0.5802971","0.57906604","0.5778637","0.5769245","0.57671094","0.57558924","0.5745359","0.5739687","0.5735042","0.57327193","0.57281333","0.5725864","0.57246685","0.5715375","0.5715165","0.5704086","0.569615","0.569615","0.5679707","0.56569433","0.5655779","0.5655775","0.565115","0.5647114","0.56448776","0.56430614","0.5630658","0.5626844","0.562415","0.56227046","0.5618824","0.5615049","0.56109834","0.5608978","0.5604278","0.56028175","0.5599166","0.5594127","0.559293","0.559009","0.55864406","0.5580699","0.5573398","0.55713755","0.55658245","0.55597425","0.55569106","0.5554782","0.5553573","0.5552101","0.5540088","0.5538859","0.55368596","0.55326355","0.55322856","0.5523411","0.5512933","0.55095553","0.54991895","0.54991895","0.54991895","0.54987156","0.54956776","0.5493905","0.54902387","0.5488334","0.5487338","0.54860073","0.5483541","0.5480828","0.5477058","0.5459435","0.54567426","0.5456294","0.5450789","0.54495585"],"string":"[\n \"0.65489256\",\n \"0.6326221\",\n \"0.6302619\",\n \"0.61190206\",\n \"0.6105587\",\n \"0.6082659\",\n \"0.6058248\",\n \"0.60442585\",\n \"0.60005426\",\n \"0.5996423\",\n \"0.59853405\",\n \"0.5955397\",\n \"0.594845\",\n \"0.59100366\",\n \"0.58981246\",\n \"0.5893184\",\n \"0.5892947\",\n \"0.58726484\",\n \"0.5856111\",\n \"0.5855935\",\n \"0.585531\",\n \"0.58434784\",\n \"0.58383936\",\n \"0.5803855\",\n \"0.5802971\",\n \"0.57906604\",\n \"0.5778637\",\n \"0.5769245\",\n \"0.57671094\",\n \"0.57558924\",\n \"0.5745359\",\n \"0.5739687\",\n \"0.5735042\",\n \"0.57327193\",\n \"0.57281333\",\n \"0.5725864\",\n \"0.57246685\",\n \"0.5715375\",\n \"0.5715165\",\n \"0.5704086\",\n \"0.569615\",\n \"0.569615\",\n \"0.5679707\",\n \"0.56569433\",\n \"0.5655779\",\n \"0.5655775\",\n \"0.565115\",\n \"0.5647114\",\n \"0.56448776\",\n \"0.56430614\",\n \"0.5630658\",\n \"0.5626844\",\n \"0.562415\",\n \"0.56227046\",\n \"0.5618824\",\n \"0.5615049\",\n \"0.56109834\",\n \"0.5608978\",\n \"0.5604278\",\n \"0.56028175\",\n \"0.5599166\",\n \"0.5594127\",\n \"0.559293\",\n \"0.559009\",\n \"0.55864406\",\n \"0.5580699\",\n \"0.5573398\",\n \"0.55713755\",\n \"0.55658245\",\n \"0.55597425\",\n \"0.55569106\",\n \"0.5554782\",\n \"0.5553573\",\n \"0.5552101\",\n \"0.5540088\",\n \"0.5538859\",\n \"0.55368596\",\n \"0.55326355\",\n \"0.55322856\",\n \"0.5523411\",\n \"0.5512933\",\n \"0.55095553\",\n \"0.54991895\",\n \"0.54991895\",\n \"0.54991895\",\n \"0.54987156\",\n \"0.54956776\",\n \"0.5493905\",\n \"0.54902387\",\n \"0.5488334\",\n \"0.5487338\",\n \"0.54860073\",\n \"0.5483541\",\n \"0.5480828\",\n \"0.5477058\",\n \"0.5459435\",\n \"0.54567426\",\n \"0.5456294\",\n \"0.5450789\",\n \"0.54495585\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60124165"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":24583,"cells":{"query":{"kind":"string","value":"This the point which Paynow polls our site with a payment status. I find it best to check with the Paynow Server. I also do the check when a payer is returned to the site when user is returned to site"},"document":{"kind":"string","value":"def paynow_update(request, payment_reference):\r\n\r\n # Get saved paymend details\r\n payment = get_object_or_404(PaynowPayment, reference=payment_reference)\r\n # Init paynow object. The URLS can be blank\r\n paynow = Paynow(settings.PAYNOW_INTEGRATION_ID, settings.PAYNOW_INTEGRATION_KEY, '', '')\r\n # Check the status of the payment with paynow server\r\n payment_result = paynow.check_transaction_status(payment.poll_url)\r\n\r\n save_changes = False\r\n\r\n # check if status has changed\r\n if payment.status != payment_result.status:\r\n payment.status = payment_result.status\r\n save_changes = True\r\n\r\n # Check if paynow reference has changed\r\n if payment.paynow_reference != payment_result.paynow_reference:\r\n payment.paynow_reference = payment_result.paynow_reference\r\n save_changes = True\r\n\r\n # Check if payment is now paid\r\n if payment_result.paid:\r\n if not payment.paid:\r\n payment.paid = True\r\n payment.confirmed_at = timezone.now()\r\n\r\n if save_changes:\r\n payment.save()\r\n\r\n return HttpResponse('ok')"},"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 check_payment_status():\n\ttry:\n\t\torders = []\n\t\terror_log = {}\n\t\tfields = [\"name\", \"sales_tokens\"]\n\t\tfilters = {\n\t\t\t\"payment_status\": (\"in\", [\"Pending\", \"\", None]),\n\t\t\t\"docstatus\": (\"!=\", 2),\n\t\t\t\"mode_of_order\": \"Web\"\n\t\t}\n\t\tdue_orders = frappe.get_list(\"Sales Order\", fields=fields, filters=filters)\n\t\tif len(due_orders):\n\t\t\turl = \"https://testicredit.rivhit.co.il/API/PaymentPageRequest.svc/SaleDetails\"\n\t\t\theaders = {\"Content-Type\": \"application/json\", \"user-agent\": \"Playfunction App\"}\n\t\t\tmethod = \"POST\"\n\n\t\t\tfor order in due_orders:\n\t\t\t\ttokens = order.get(\"sales_tokens\")\n\t\t\t\tsales_token = json.loads(tokens)[\"PrivateSaleToken\"]\n\t\t\t\tdata = {\"SalePrivateToken\": sales_token}\n\t\t\t\tresponse = request(method, url, data=json.dumps(data), headers=headers)\n\t\t\t\t# check payment status\n\t\t\t\tif response.status_code == 200:\n\t\t\t\t\tresponse = json.loads(response.text)\n\t\t\t\t\tif not response.get(\"status\") and response.get(\"Amount\") \\\n\t\t\t\t\t\tand response.get(\"AuthNum\"):\n\t\t\t\t\t\t# TODO: partial payment - response.get(\"Amount\") != order amt\n\t\t\t\t\t\tfrappe.db.set_value(\"Sales Order\", order.get(\"name\"), \"payment_status\", \"Paid\")\n\t\t\t\t\t\tfrappe.db.commit()\n\t\t\t\telse:\n\t\t\t\t\t# update error log\n\t\t\t\t\terror_log[order.get(\"name\")] = response.text\n\t\tif error_log.keys():\n\t\t\tfrappe.error_log(message=json.dumps(error_log), title=\"Scheduler Event Failed\")\n\texcept Exception as e:\n\t\tfrappe.log_error(message=frappe.get_traceback() , title=\"Scheduler Event: check_payment_status\")","def awaiting_payment(self):","def paynow_return(request, payment_id):\r\n # Get payment object\r\n payment = get_object_or_404(PaynowPayment, reference=payment_id)\r\n # Init Paynow oject. The urls can now be blank\r\n paynow = Paynow(settings.PAYNOW_INTEGRATION_ID, settings.PAYNOW_INTEGRATION_KEY, '', '')\r\n\r\n # Check the status of the payment with the paynow server\r\n payment_result = paynow.check_transaction_status(payment.poll_url)\r\n\r\n save_changes = False\r\n\r\n # check if status has changed\r\n if payment.status != payment_result.status:\r\n payment.status = payment_result.status\r\n save_changes = True\r\n\r\n # Check if paynow reference has changed\r\n if payment.paynow_reference != payment_result.paynow_reference:\r\n payment.paynow_reference = payment_result.paynow_reference\r\n save_changes = True\r\n\r\n # Check if payment is now paid\r\n print(payment_result.paid)\r\n if payment_result.paid:\r\n if not payment.paid:\r\n payment.paid = True\r\n payment.confirmed_at = timezone.now()\r\n\r\n if save_changes:\r\n payment.save()\r\n\r\n msg = \"Payment for Transaction \" + payment.reference + ' confirmed'\r\n msg += \" Paynow Reference: \" + payment.paynow_reference\r\n messages.success(request, msg)\r\n msg = \"Paynow Payment status => \" + payment.status\r\n messages.success(request, msg)\r\n\r\n\r\n\r\n\r\n return redirect(reverse('index'))","def payment_check(payload):\n response = requests.post(url, data=payload)\n return response.json()","def status():\n if not session.get('user_id'):\n return redirect(url_for('home.login'))\n if request.method == 'GET':\n payment = controllers.get_last_payment(session['user_id'])\n if not payment:\n return redirect(url_for('membership.pay'))\n return render_template('status.html', payment=payment)","def payReturn(request, *args, **kwargs):\n initParam = {}\n pay_key = request.session.get('pay_key', None)\n gateway = request.session.get('gateway', None)\n if pay_key and gateway:\n del request.session['pay_key']\n del request.session['gateway']\n #Check and get Transaction information\n checkMethod = kwargs.pop('checkMethod', None)\n if checkMethod:\n initParam['pay_key'] = pay_key\n initParam['gateway'] = gateway\n transaction = checkMethod(request, initParam=initParam)\n if transaction:\n p = driver.PayPal()\n #Check whether use has paid successfully.\n result = p.check_ap_payment_status(transaction.pay_key)\n if result['status'][0] == 'COMPLETED':\n #Do something after user payed successfully.\n executeMethod = kwargs.pop('executeMethod', None)\n if executeMethod:\n initParam['transaction_id'] = transaction.id\n initParam['buyer_account'] = result['senderEmail'][0]\n if executeMethod(initParam=initParam):\n success_page = request.session.get('success_page', None)\n back_page = request.session.get('back_page', None)\n if back_page:\n del request.session['back_page']\n if success_page:\n del request.session['success_page']\n initParam['success_page'] = success_page\n initParam['success_page_msg'] = request.session['success_page_msg']\n #For the value in paypal_success.html\n initParam['app'] = transaction.app\n initParam['price'] = transaction.price\n initParam['type'] = 'Transaction'\n initParam['msg'] = _('You have successfully paid the money. We have already sent an email to the app seller. In the meanwhile you can send private message to seller as well.')\n log.info(_('User %(param1)s has paid with transaction id %(param2)s.')\n % {'param1': request.user.username, 'param2': transaction.id})\n return render_to_response(\"payment/paypal_success.html\", initParam, context_instance=RequestContext(request))\n else:\n log.error(_('User %(param1)s has paid with transaction id %(param2)s, but execute method %(param3)s failed.')\n % {'param1': request.user.username, 'param2': transaction.id, 'param3': executeMethod.__name__})\n else:\n log.error(_('User %(param1)s has paid with transaction id %(param2)s, but ExecuteMethod does not exist.')\n % {'param1': request.user.username, 'param2': transaction.id})\n else:\n log.error(_('User %(param1)s has no paid with transaction id %(param2)s.')\n % {'param1': request.user.username, 'param2': transaction.id})\n else:\n log.error(_('PayKey %(param1)s, Gateway: %(param2)s, User: %(param3)s, Execute method %(param4)s failed.')\n % {'param1': pay_key, 'param2': gateway, 'param3': request.user.username, 'param4': checkMethod.__name__})\n else:\n log.error(_('PayKey %(param1)s, Gateway: %(param2)s, CheckMethod does not exist.')\n % {'param1': pay_key, 'param2': gateway})\n else:\n log.error(_('Pay. PayKey or Gateway no exists.'))\n\n success_page = request.session.get('success_page', None)\n back_page = request.session.get('back_page', None)\n if success_page:\n del request.session['success_page']\n if back_page:\n del request.session['back_page']\n error_msg = driver.GENERIC_PAYPAL_ERROR\n page_msg = request.session['back_page_msg']\n return render_to_response('payment/paypal_cancel.html',\n {'error_msg': error_msg, 'back_page': back_page, 'back_page_msg': page_msg}, context_instance=RequestContext(request))\n else:\n error_msg = _('%(param1)s Please transaction again.') % {'param1': driver.GENERIC_PAYPAL_ERROR}\n return render_to_response('payment/paypal_error.html',\n {\"error_msg\": error_msg}, context_instance=RequestContext(request))","def check_payment(self):\n return self.payment","def payment_verification(payload):\n response = requests.post(url, data=payload)\n return response.json()","def payPalDoCheckOut(request, *args, **kwargs):\n initParam = {}\n id = request.GET.get(\"id\")\n token = request.GET.get(\"token\")\n payerID = request.GET.get(\"PayerID\")\n initParam['id'] = id\n initParam['token'] = token\n if token and payerID and id:\n #Check and get Service detail information\n checkMethod = kwargs.pop('checkMethod', None)\n if checkMethod:\n gateway = request.session.get('gateway', None)\n if gateway:\n del request.session['gateway']\n initParam['gateway'] = gateway\n serviceDetail = checkMethod(request, initParam=initParam)\n if serviceDetail:\n amount = serviceDetail.actual_amount\n currency = serviceDetail.app.currency.currency\n result, response = utils.process_payment_request(amount, currency, token, payerID)\n if result:\n #Do something after payment success.\n executeMethod = kwargs.pop('executeMethod', None)\n if executeMethod:\n initParam['serviceDetail_id'] = serviceDetail.id\n if executeMethod(request, initParam=initParam):\n success_page = request.session.get('success_page', None)\n back_page = request.session.get('back_page', None)\n if back_page:\n del request.session['back_page']\n if success_page:\n del request.session['success_page']\n initParam['success_page'] = success_page\n initParam['success_page_msg'] = request.session['success_page_msg']\n #For the value in paypal_success.html\n initParam['app'] = serviceDetail.app\n initParam['type'] = 'Payment'\n initParam['price'] = serviceDetail.actual_amount\n initParam['msg'] = _('Thank you for your payment, and your app will be listed according to the effective period your choosed.')\n log.info(_('Seller %(param1)s has paid service fee with service detail id %(param2)s.')\n % {'param1': request.user.username, 'param2': serviceDetail.id})\n return render_to_response(\"payment/paypal_success.html\", initParam, context_instance=RequestContext(request))\n else:\n log.error(_('Token %(param1)s, PayerID: %(param2)s, Execute method %(param3)s failed.')\n % {'param1': token, 'param2': payerID, 'param3': executeMethod.__name__})\n else:\n log.error(_('Token %(param1)s, PayerID: %(param2)s, ExecuteMethod does not exist.')\n % {'param1': token, 'param2': payerID})\n else:\n log.error(_('Token %(param1)s, PayerID: %(param2)s, %(param3)s : %(param4)s.')\n % {'param1': token, 'param2': payerID, 'param3': response.error, 'param4': response.error_msg})\n else:\n log.error(_('Token %(param1)s, PayerID: %(param2)s, User: %(param3)s, Execute method %(param4)s failed.')\n % {'param1': token, 'param2': payerID, 'param3': request.user.username, 'param4': checkMethod.__name__})\n else:\n log.error(_('Token %(param1)s, PayerID: %(param2)s, Gateway no exists in request.session.')\n % {'param1': token, 'param2': payerID})\n else:\n log.error(_('Token %(param1)s, PayerID: %(param2)s, CheckMethod does not exist.')\n % {'param1': token, 'param2': payerID})\n else:\n log.error(_('Token or PayerID no exists.'))\n\n if request.session.get('gateway', None):\n del request.session['gateway']\n success_page = request.session.get('success_page', None)\n back_page = request.session.get('back_page', None)\n if success_page:\n del request.session['success_page']\n if back_page:\n del request.session['back_page']\n error_msg = driver.GENERIC_PAYPAL_ERROR\n page_msg = request.session['back_page_msg']\n return render_to_response('payment/paypal_cancel.html',\n {'error_msg': error_msg, 'back_page': back_page, 'back_page_msg': page_msg}, context_instance=RequestContext(request))\n else:\n error_msg = _('%(param1)s Please payment again.') % {'param1': driver.GENERIC_PAYPAL_ERROR}\n return render_to_response('payment/paypal_error.html',\n {\"error_msg\": error_msg}, context_instance=RequestContext(request))","def run_now(request):\n rp_id = request.POST.get('rp_id')\n rp = get_object_or_404(RecurringPayment, pk=rp_id)\n\n result_data = {}\n result_data['processed'] = 'false'\n result_data['reason'] = 'done'\n\n payment_profiles = PaymentProfile.objects.filter(\n customer_profile_id=rp.customer_profile_id,\n status=True,\n status_detail='active'\n ).order_by('-update_dt')\n if not payment_profiles:\n valid_cpp_ids, invalid_cpp_ids = rp.populate_payment_profile()\n #print valid_cpp_ids, invalid_cpp_ids\n\n if valid_cpp_ids:\n payment_profiles = PaymentProfile.objects.filter(\n customer_profile_id=valid_cpp_ids[0])\n\n if not payment_profiles:\n result_data['reason'] = 'not setup'\n else:\n if rp.status_detail == 'active':\n num_processed = run_a_recurring_payment(rp)\n if num_processed:\n result_data['processed'] = 'true'\n result_data['reason'] = 'processed'\n # get total_paid and balance for this rp\n result_data['total_paid'] = str(rp.total_paid)\n result_data['balance'] = str(rp.get_outstanding_balance())\n\n # get total amount received for all rps\n d = RecurringPaymentInvoice.objects.filter(\n invoice__balance=0,\n ).aggregate(total_amount_received=Sum('invoice__total'))\n result_data['total_amount_received'] = d['total_amount_received']\n if not result_data['total_amount_received']:\n result_data['total_amount_received'] = 0\n result_data['total_amount_received'] = tcurrency(result_data['total_amount_received'])\n\n return HttpResponse(simplejson.dumps(result_data))","def verifysubscriptionstatusinaccounttab():\n pass","def proceed_to_checkout_and_payment(self):\r\n # 1- summary\r\n logger.info('starting wizard with summary')\r\n self.automation.wait.until(\r\n EC.presence_of_element_located((By.CSS_SELECTOR, '.cart_navigation a.standard-checkout')))\r\n self.automation.driver.execute_script(\"document.querySelectorAll('.cart_navigation a.standard-checkout')[0]\"\r\n \".click()\")\r\n\r\n # 2-sign in & 3-address\r\n logger.info('2-sign in & 3-address')\r\n self.automation.wait.until(\r\n EC.presence_of_element_located((By.CSS_SELECTOR, 'button[name=\"processAddress\"]')))\r\n\r\n self.automation.driver.find_element_by_css_selector('button[name=\"processAddress\"]').click()\r\n\r\n # 4- shipping\r\n logger.info('4- shipping')\r\n self.automation.wait.until(\r\n EC.presence_of_element_located((By.CSS_SELECTOR, '#uniform-cgv span')))\r\n\r\n is_checked = self.automation.driver.find_element_by_css_selector('#uniform-cgv span').get_attribute('class')\r\n if not is_checked: # agree\r\n self.automation.driver.execute_script(\"document.querySelectorAll('#cgv')[0].click()\")\r\n\r\n self.automation.driver.find_element_by_css_selector('button[name=processCarrier]').click()\r\n logger.info('agree and confirmed')\r\n\r\n # pay by bank wire\r\n logger.info('pay by bank wire')\r\n self.automation.wait.until(\r\n EC.presence_of_element_located((By.CSS_SELECTOR, '.payment_module a')))\r\n\r\n self.automation.driver.find_element_by_css_selector('.payment_module a').click()\r\n\r\n # 5- payment and confirm\r\n logger.info('5- payment and confirm')\r\n self.automation.wait.until(\r\n EC.presence_of_element_located((By.CSS_SELECTOR, '#cart_navigation button')))\r\n self.automation.driver.find_element_by_css_selector('#cart_navigation button').click()\r\n\r\n # back to orders\r\n logger.info('back to orders')\r\n self.automation.wait.until(\r\n EC.presence_of_element_located((By.CSS_SELECTOR, 'p.cart_navigation .button-exclusive.btn')))\r\n self.automation.driver.find_element_by_css_selector('p.cart_navigation .button-exclusive.btn').click()\r\n\r\n # how many items do you have\r\n time.sleep(1.5)\r\n self.automation.wait.until(\r\n EC.presence_of_element_located((By.CSS_SELECTOR, '#order-list tbody tr')))\r\n items = self.automation.driver.find_elements_by_css_selector('#order-list tbody tr')\r\n logger.info(f'You have \"{len(items)}\" at your order')","def check() -> bool:\n today = datetime.now(timezone(timedelta(hours=2)))\n second_period = today + timedelta(days=7)\n third_period = second_period + timedelta(days=7)\n periods = list(\n map(\n lambda item: item.strftime(\"%Y-%m-%d\"), [today, second_period, third_period]\n )\n )\n\n periods_urls = map(\n lambda item: f\"https://ezakupy.tesco.pl/groceries/pl-PL/slots/delivery/{item}?slotGroup=2\",\n periods,\n )\n url_login = \"https://ezakupy.tesco.pl/groceries/pl-PL/login\"\n\n session = requests.Session()\n\n response_login_form = session.get(url_login)\n soup = BeautifulSoup(response_login_form.content, features=\"html.parser\")\n csrf_token = soup.find(attrs={\"name\": \"_csrf\"}).attrs[\"value\"]\n\n session.post(\n url_login,\n data={\n \"onSuccessUrl\": \"\",\n \"email\": os.environ.get(\"TESCO_EMAIL\", \"\"),\n \"password\": os.environ.get(\"TESCO_PASSWORD\", \"\"),\n \"_csrf\": csrf_token,\n },\n headers={\"Content-Type\": \"application/x-www-form-urlencoded\"},\n )\n\n period_results = map(lambda url: get_slots_for_date(url, session), periods_urls)\n list_of_slots = []\n\n for period_result in period_results:\n for slot in period_result:\n list_of_slots.append(slot)\n\n if len(list_of_slots) > 0:\n send_email(\n email_address(), \"Free slot available\", f\"Free slots {len(list_of_slots)}\"\n )\n print(\"Free slot available. \", len(list_of_slots))\n return True\n else:\n print(\"No available slots\")\n return False","def run(self):\n self.getPrice()\n #time.sleep(5)\n self.compare_price()\n #time.sleep(5)\n if self.__alert_client is True:\n self.send_email()\n #self.display()\n return True\n else:\n #self.display()\n return False","def slot_poll(self, _sender, _data):\r\n if self.client.secret and self.client.secret.know_secret():\r\n # poll recent own trades\r\n # fixme: how do i do this, whats the api for this?\r\n pass","def payment(self, **post):\n cr, uid, context = request.cr, request.uid, request.context\n payment_obj = request.registry.get('payment.acquirer')\n sale_order_obj = request.registry.get('sale.order')\n\n order = request.website.sale_get_order(context=context)\n order.write({'usersess': request.session['webcalc_session_id']})\n #order.env.cr.commit()\n redirection = self.checkout_redirection(order)\n if redirection:\n return redirection\n\n shipping_partner_id = False\n if order:\n if order.partner_shipping_id.id:\n shipping_partner_id = order.partner_shipping_id.id\n else:\n shipping_partner_id = order.partner_invoice_id.id\n\n values = {\n 'order': request.registry['sale.order'].browse(cr, SUPERUSER_ID, order.id, context=context),\n 'usersess': request.session['webcalc_session_id']\n }\n values['errors'] = sale_order_obj._get_errors(cr, uid, order, context=context)\n values.update(sale_order_obj._get_website_data(cr, uid, order, context))\n\n if not values['errors']:\n acquirer_ids = payment_obj.search(cr, SUPERUSER_ID, [('website_published', '=', True), ('company_id', '=', order.company_id.id)], context=context)\n values['acquirers'] = list(payment_obj.browse(cr, uid, acquirer_ids, context=context))\n render_ctx = dict(context, submit_class='btn btn-primary', submit_txt=_('Завершить оформление'))\n for acquirer in values['acquirers']:\n acquirer.button = payment_obj.render(\n cr, SUPERUSER_ID, acquirer.id,\n '/',\n order.amount_total,\n order.pricelist_id.currency_id.id,\n partner_id=shipping_partner_id,\n tx_values={\n 'return_url': '/shop/payment/validate',\n },\n context=render_ctx)\n #vips_shop\n return request.website.render(\"vips_shop.payment\", values)","def checkPayComplete(*args, **kwargs):\n initParam = {}\n transaction = kwargs.get('transaction')\n if transaction:\n p = driver.PayPal()\n #Check whether use has paid successfully.\n result = p.check_ap_payment_status(transaction.pay_key)\n if result['status'][0] != 'COMPLETED':\n #Do something after user payed successfully.\n executeMethod = kwargs.pop('executeMethod', None)\n if executeMethod:\n initParam['transaction_id'] = transaction.id\n initParam['pay_key'] = transaction.pay_key\n initParam['buyer_account'] = result['senderEmail'][0]\n executeMethod(initParam=initParam)","def getStatus(entry, vType):\n data = db.Database(filename=\"IFB299.db\")\n fine = data.retrieveFine(vType, entry['Citation_Number'])\n if fine['Payment_status'] == \"Pending\":\n date = dt.datetime.strptime(entry['Date'],'%d/%m/%Y')\n overdue = dt.datetime.now().date() - date.date()\n if overdue.days >= 7:\n return \"Overdue\"\n else:\n return \"Pending\"\n else:\n return \"Paid\"","def isw_callback(md=None, pa_res=None):\n url = cardinal_endpoint + '/collections/api/v1/pay/cardinalCallBack'\n\n headers = {'Accept':'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',\n 'Accept-Encoding':'gzip, deflate, br',\n 'Accept-Language':'fr-FR,fr;q=0.9,en-GB;q=0.8,en;q=0.7,fr-CA;q=0.6,en-US;q=0.5',\n 'Content-Length':'4170',\n 'Content-Type':'application/x-www-form-urlencoded',\n 'User-Agent':'Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.146 Safari/537.36'}\n\n data = {'MD': md,'PaRes':pa_res}\n\n make_request = requests.post(url, data=data, headers=headers)\n visa_purchase = make_request.status_code\n print(visa_purchase)\n if visa_purchase == 200:\n return True\n else:\n return False","def check_status(self):","def test_buy_now(self):\n catalog_page = CatalogPage(self.driver)\n product_page = ProductPage(self.driver)\n payment_page = PaymentPage(self.driver)\n payment_review_page = PaymentReviewPage(self.driver)\n payment_info_page = PaymentInfoPage(self.driver)\n success_page = SuccessPage(self.driver)\n # buy the new product\n navigate_to(self.driver, ProductPage.URL(self.new_product['product']['title']))\n product_page.add_to_cart.click()\n # by an old product\n catalog_page.catalog.click()\n # Sort products to move the newly created to last page\n catalog_page.sorting_order.select_by_visible_text(\"Date, old to new\")\n catalog_page.image.random_click()\n product = product_page.product.get_text()\n product_page.add_to_cart.click()\n catalog_page.catalog.click()\n catalog_page.cart.click()\n payment_dic = {\n 'address' : f'{randint(1, 99999)} {random_name(5, 8)}',\n 'city' : \"San Francisco\",\n 'email_or_mobile_phone_number_input' : random_name(8) + \"@gmail.com\",\n 'last_name' : random_name(3, 12),\n 'zip_code' : '94107',\n }\n if randint(0, 1):\n payment_dic['first_name'] = random_name(4, 16)\n if randint(0, 1):\n payment_dic['address2'] = random_name(5)\n for _ in payment_dic:\n exec(f\"payment_page.{_}.enter(payment_dic['{_}'])\")\n payment_page.continue_to_shipping.click()\n payment_review_page.continue_to_payment.click()\n payment_info_page.full_address.get_text()\n # validate address\n for _ in ['address', 'city', 'zip_code']:\n assert_and_log(payment_dic[_] in payment_info_page.full_address.get_text(),\n f\"{_} in full address\")\n payment_info_page.enter_bogus_payment(1)\n assert_and_log(success_page.thank_you.find_visible_element(),\n \"'Thank you' appeared as a sign of successful transaction\",\n continue_on_error=False)\n validate(success_page.basic_validation_list)","def test_authorize_pending_payment(self):\n pass","def is_payout_available(self):\r\n return False # Disabled because artist receives payout directly from fan\r\n # return self.has_ended and not self.is_payout_requested and self.amount_raised_online and not self.is_deleted\r","def pay_in_full():\n _validate_fields(PAYMENT_FIELDS)\n dbhandlers.handle_pay_in_full(request.form)\n return dumps({\"response\": \"success\"})","def process_payment():\n\n url = 'https://api.worldpay.com/v1/orders'\n headers = {'Authorization': environ.get('WORLDPAY_API_KEY'),\n 'Content-type': 'application/json'}\n body = {\n \"paymentMethod\": {\n \"type\": \"Card\",\n \"name\": session['caller_name'],\n \"expiryMonth\": session['expiry'][:2],\n \"expiryYear\": f\"20{session['expiry'][2:]}\",\n \"cardNumber\": session['card_number'],\n \"cvc\": session['cvv'],\n \"issueNumber\": \"1\"\n },\n \"orderType\": \"ECOM\",\n \"orderDescription\": session['call_sid'],\n \"amount\": session['payment_amount'],\n \"currencyCode\": \"GBP\"}\n r = requests.post(url, headers=headers, data=json.dumps(body))\n requests.post(environ.get('END_OF_INTERACTION_URL'), r.text)\n response = VoiceResponse()\n response.say(\"Payment processed, goodbye\")\n # If your flow started in Twilio Studio, redirect back to it to complete the call\n # response.redirect(\n # 'https://webhooks.twilio.com/v1/Accounts/ACfd0573f9f976b99746c693XXXXXXXXXX/Flows/FWbfdeda0a21644267231d3dXXXXXXXXXX?FlowEvent=return')\n return str(response)","def test_deny_pending_payment(self):\n pass","def no_payment_required(self):","def payPalReturn(request, *args, **kwargs):\n initParam = {}\n token = request.GET.get('token')\n payerID = request.GET.get('PayerID')\n initParam['token'] = token\n initParam['payerid'] = payerID\n if token and payerID:\n p = driver.PayPal()\n EC_RETURNURL = '/'.join([common.getHttpHeader(request), 'payment/paypal_return'])\n EC_CANCELURL = '/'.join([common.getHttpHeader(request), 'payment/paypal_cancel'])\n res_dict = p.GetExpressCheckoutDetailsInfo(EC_RETURNURL, EC_CANCELURL, token)\n state = p._get_value_from_qs(res_dict, 'ACK')\n if state in [\"Success\", \"SuccessWithWarning\"]:\n #Show the list of service detail to user.\n executeMethod = kwargs.pop('executeMethod', None)\n if executeMethod:\n gateway = request.session.get('gateway', None)\n if gateway:\n initParam['gateway'] = gateway\n serviceDetail, serviceItems, discount_rate = executeMethod(request, initParam=initParam)\n if serviceDetail and serviceItems:\n initParam['serviceDetail'] = serviceDetail\n initParam['serviceItems'] = serviceItems\n initParam['discount_rate'] = discount_rate\n return render_to_response('payment/paypal_return.html', initParam, context_instance=RequestContext(request))\n else:\n log.error(_('Token %(param1)s, PayerID: %(param2)s, Execute method %(param3)s failed.')\n % {'param1': token, 'param2': payerID, 'param3': executeMethod.__name__})\n else:\n log.error(_('Token %(param1)s, PayerID: %(param2)s. Gateway no exists in request.session.')\n % {'param1': token, 'param2': payerID})\n else:\n log.error(_('Token %(param1)s, PayerID: %(param2)s, ExecuteMethod does not exist.')\n % {'param1': token, 'param2': payerID})\n else:\n error = p._get_value_from_qs(res_dict, 'L_SHORTMESSAGE0')\n log.error(_('Token %(param1)s, PayerID: %(param2)s, %(param3)s.')\n % {'param1': token, 'param2': payerID, 'param3': error})\n else:\n log.error(_('Token or PayerID no exists.'))\n\n if request.session.get('gateway', None):\n del request.session['gateway']\n success_page = request.session.get('success_page', None)\n back_page = request.session.get('back_page', None)\n if success_page:\n del request.session['success_page']\n if back_page:\n del request.session['back_page']\n error_msg = driver.GENERIC_PAYPAL_ERROR\n page_msg = request.session['back_page_msg']\n return render_to_response('payment/paypal_cancel.html',\n {'error_msg': error_msg, 'back_page': back_page, 'back_page_msg': page_msg}, context_instance=RequestContext(request))\n else:\n error_msg = _('%(param1)s Please payment again.') % {'param1': driver.GENERIC_PAYPAL_ERROR}\n return render_to_response('payment/paypal_error.html',\n {\"error_msg\": error_msg}, context_instance=RequestContext(request))","def credit_deliverer():\n return True","def check_award_status(request, award, now):\n auction = request.validated['auction']\n protocol_overdue = protocol_overdue_predicate(award, 'pending.verification', now)\n contract_overdue = contract_overdue_predicate(award, 'active', now)\n payment_overdue = (award.status == 'pending.payment' and award['paymentPeriod']['endDate'] < now)\n if protocol_overdue or contract_overdue or payment_overdue:\n set_unsuccessful_award(request, auction, award, now)","def get_status() -> None:\n assert scraper.get_status() == True","def test_get_pay_in_details(self):\n pass","def test_retrieve_iso20022_payment_instruction_status_report(self):\n pass","def paid(self):\n return self.get('paid')","def webhook_payment_successful(self, event):\n\n intent = event.data.object\n p_id = intent.id\n pack = intent.metadata.pack\n save_detail = intent.metadata.save_detail\n\n billing_details = intent.charges.data[0].billing_details\n shipping_details = intent.shipping\n grand_cost = round(intent.charges.data[0].amount / 100, 2)\n\n for field, value in shipping_details.address.items():\n if value == \"\":\n shipping_details.address[field] = None\n\n profile = None\n username = intent.metadata.username\n if username != 'AnonymousUser':\n profile = UserProfile.objects.get(user__username=username)\n if save_detail:\n profile.default_phone_number = shipping_details.phone,\n profile.default_home_Address = shipping_details.address.line1,\n profile.default_home_Address_continued = \\\n shipping_details.address.line2,\n profile.default_postcode = \\\n shipping_details.address.postal_code,\n profile.default_county = \\\n shipping_details.address.city,\n profile.default_country = \\\n shipping_details.address.country,\n profile.save()\n\n order_present = False\n seek = 1\n while seek <= 6:\n try:\n order = Order.objects.get(\n Name__iexact=shipping_details.name,\n user_account=profile,\n email__iexact=billing_details.email,\n phone_number__iexact=shipping_details.phone,\n home_Address__iexact=shipping_details.address.line1,\n home_Address_continued__iexact =(\n shipping_details.address.line2\n ),\n postcode__iexact=shipping_details.address.postal_code,\n county__iexact=shipping_details.address.city,\n country__iexact=shipping_details.address.country,\n grand_cost=grand_cost,\n original_pack=pack,\n stripe_p_id=p_id,\n )\n order_present = True\n break\n except Order.DoesNotExist:\n seek += 1\n time.sleep(1)\n if order_present:\n self._send_email_details(order)\n return HttpResponse(\n content=f'Webhook obtained: {event[\"type\"]} | Good news. \\\n This is now in the database',\n status=200)\n else:\n order = None\n try:\n order = Order.objects.create(\n Name=shipping_details.name,\n email=billing_details.email,\n phone_number=shipping_details.phone,\n home_Address=shipping_details.address.line1,\n home_Address_continued=shipping_details.address.line2,\n postcode=shipping_details.address.postal_code,\n county=shipping_details.address.city,\n country=shipping_details.address.country,\n original_pack=pack,\n stripe_p_id=p_id,\n )\n for item_id, item_data in json.load(pack).items():\n product = Product.objects.get(id=item_id)\n if isinstance(item_data, int):\n order_line_item = OrderLineItem(\n order=order,\n product=product,\n quantity=item_data,\n )\n order_line_item.save()\n else:\n for size, quantity in item_data['items_by_size'].items():\n order_line_item = OrderLineItem(\n order=order,\n product=product,\n quantity=quantity,\n product_size=size,\n )\n order_line_item.save()\n except Exception as e:\n if order:\n order.delete()\n return HttpResponse(\n content=f'Webhook obtained: {event[\"type\"]} | \\\n There is an error: {e}',\n status=500)\n self._send_email_details(order)\n return HttpResponse(\n content=f'Webhook obtained: {event[\"type\"]} | \\\n Goodnews: webhook order created',\n status=200)","def validate_with_paypal(request, validate_type):\n if validate_type == 'PDT':\n # we are on return url\n # need to verify if payment is completed\n # MERCHANT_TXN_KEY is your PDT identity token\n params = {\n 'cmd': '_notify-synch',\n 'tx': request.GET.get('tx', ''),\n 'at': settings.MERCHANT_TXN_KEY\n }\n data = urllib.urlencode(params)\n\n # Sample response:\n # SUCCESS\n # first_name=Jane+Doe\n # last_name=Smith\n # payment_status=Completed payer_email=janedoesmith%40hotmail.com\n # payment_gross=3.99\n # mc_currency=USD custom=For+the+purchase+of+the+rare+book+Green+Eggs+%26+Ham\n\n # If the response is FAIL, PayPal recommends making sure that:\n # The Transaction token is not bad.\n # The ID token is not bad.\n # The tokens have not expired.\n\n else: # IPN\n data = 'cmd=_notify-validate&%s' % request.POST.urlencode()\n\n # The response is one single-word: VERIFIED or INVALID\n\n headers = {\"Content-type\": \"application/x-www-form-urlencoded\",\n 'encoding': 'utf-8',\n \"Accept\": \"text/plain\"}\n request = urllib2.Request(settings.PAYPAL_POST_URL,\n data,\n headers)\n response = urllib2.urlopen(request)\n data = response.read()\n\n if validate_type == 'PDT':\n return parse_pdt_validation(data)\n else:\n return data.strip('\\n').lower() == 'verified', None","def event_payu_com_dpn(self, **post):\n cr, uid, context = request.cr, request.uid, request.context\n payment_acquire = request.env['payment.acquirer'].sudo().search([('provider', '=', 'payu')])\n transactionDetails = {}\n transactionDetails['store'] = {}\n transactionDetails['store']['soapUsername'] = payment_acquire.payu_api_username\n transactionDetails['store']['soapPassword'] = payment_acquire.payu_api_password\n transactionDetails['store']['safekey'] = payment_acquire.payu_seller_account\n transactionDetails['store']['environment'] = payment_acquire.environment\n transactionDetails['additionalInformation'] = {}\n transactionDetails['additionalInformation']['payUReference'] = post['PayUReference']\n try:\n result = PayuController.payuMeaGetTransactionApiCall('', transactionDetails)\n payment_transation_id = request.env['payment.transaction'].sudo().search(\n [('reference', '=', result['merchantReference'])])\n payu_response = {}\n if result:\n payu_response['TRANSACTION_STATUS'] = result['transactionState']\n # payu_response['SUCCESSFUL'] = result['successful']\n payu_response['AMOUNT'] = payment_transation_id.amount * 100 if payment_transation_id else 0.00\n payu_response['CURRENCYCODE'] = result['basket']['currencyCode']\n payu_response['PAYUREFERENCE'] = result['payUReference']\n payu_response['REFERENCE'] = result['merchantReference']\n payu_response['RESULTMESSAGE'] = result['resultMessage']\n response_state = request.env['payment.transaction'].sudo().form_feedback(payu_response, 'payu')\n # response_state = PaymentTransactionCus.form_feedback('', payu_response, 'payu')\n # if response_state:\n # return werkzeug.utils.redirect('/shop/payment/validate')\n # else:\n # return werkzeug.utils.redirect('/shop/unsuccessful')\n\n sale_order_id = request.env['sale.order'].sudo().search([('name', '=', result['merchantReference'])])\n sale_order_data = sale_order_id\n request.session['sale_last_order_id'] = sale_order_id.id\n\n tx_id = request.env['payment.transaction'].sudo().search([('reference', '=', result['merchantReference'])])\n tx = tx_id\n if not sale_order_id or (sale_order_id.amount_total and not tx):\n return request.redirect('/shop')\n if (not sale_order_id.amount_total and not tx) or tx.state in ['pending']:\n if sale_order_id.state in ['draft', 'sent']:\n if (not sale_order_id.amount_total and not tx):\n sale_order_id.action_button_confirm()\n email_act = sale_order_id.action_quotation_send()\n elif tx and tx.state == 'cancel':\n sale_order_id.action_cancel()\n elif tx and (tx.state == 'draft' or tx.state == 'sent' or tx.state == 'done'):\n # if result and payu_response['successful'] and payu_response['TRANSACTION_STATUS'] in ['SUCCESSFUL', 'PARTIAL_PAYMENT', 'OVER_PAYMENT']:\n if result and payu_response['TRANSACTION_STATUS'] in ['SUCCESSFUL', 'PARTIAL_PAYMENT', 'OVER_PAYMENT']:\n transaction = tx.sudo().write(\n {'state': 'done', 'date_validate': datetime.now(),\n 'acquirer_reference': result['payUReference']})\n email_act = sale_order_id.action_quotation_send()\n action_confirm_res = sale_order_id.action_confirm()\n sale_order = sale_order_id.read([])\n # if sale_order_id.state == 'sale':\n # journal_ids = request.env['account.journal'].sudo().search([('name', '=', 'FNB 62085815143')], limit=1)\n # journal = journal_ids.read([])\n currency = request.env['res.currency'].sudo().search([('name', '=', 'ZAR')], limit=1)\n method = request.env['account.payment.method'].sudo().search([('name', '=', 'Manual')], limit=1)\n journal_id = request.env['account.journal'].sudo().search(\n [('name', '=', 'FNB - Cheque Account 6208585815143')], limit=1, order=\"id desc\")\n if journal_id:\n account_payment = {\n 'partner_id': sale_order[0]['partner_id'][0],\n 'partner_type': 'customer',\n 'journal_id': journal_id.id,\n # 'invoice_ids':[(4,inv_obj.id,0)],\n 'amount': sale_order[0]['amount_total'],\n 'communication': sale_order_id.name,\n 'currency_id': currency.id,\n 'payment_type': 'inbound',\n 'payment_method_id': method.id,\n 'payment_transaction_id': tx.id,\n }\n acc_payment = request.env['account.payment'].sudo().create(account_payment)\n acc_payment.sudo().post()\n sale_order_id = request.session.get('sale_last_order_id')\n print(\"\\n\\n\\n\\n\\n\\n=======================sale order sale order======\", sale_order_id)\n sale_order_data = request.env['sale.order'].sudo().browse(sale_order_id)\n # if sale_order_data.project_project_id:\n # request.session['last_project_id'] = sale_order_data.project_project_id.id\n if response_state:\n sale_order_data.message_post(subject=\"T&C's Privacy Policy\",\n body=\"%s accepted T&C's and Privacy Policy.\" % sale_order_data.partner_id.name)\n return werkzeug.utils.redirect('/pay/thankyou')\n # return werkzeug.utils.redirect('/shop/confirmation')\n else:\n return werkzeug.utils.redirect('/event/unsuccessful')\n except Exception as e:\n return werkzeug.utils.redirect('/event/unsuccessful')","def do(self):\n self.message += 'Searching for unpayed loans \\n'\n today = dt.now()\n tomorrow = today + timedelta(days=1)\n\n expired = Loan.objects.filter(due_date=today)\n almost = Loan.objects.filter(due_date=tomorrow)\n\n self.charge(expired)\n self.notify(almost)\n\n self.log_success()","def hit_send_payment_button(self):\n\t\telement = Element(driver=self.driver,\n\t\t explicit_wait_time=self.explicit_wait_time,\n\t\t locator=BillPayPageLocator.SEND_PAYMENT_BUTTON)\n\t\telement.click_on()\n\t\treturn None","def getPayment(self):\n pass","def post(self):\n policies = json.loads(self.request.get('policies'))\n request = json.loads(self.request.get('request_json'))\n response = json.loads(self.request.get('response_json'))\n\n maybe_notify_backend('LEASED', response['hostname'], policies)\n maybe_notify_lessee(request, response)","def __check(self):\n status = '200 OK'\n try:\n response = get(self.__url)\n status = '{} {}'.format(\n response.status_code,\n http.client.responses[response.status_code]\n )\n except Exception as e:\n status = e.__class__.__name__\n \n if status[:3] == '200':\n self.__notify_up()\n else:\n if not self.downtime_info:\n self.downtime_info = DowntimeInfo(status)\n self.__notify_down()","def payments(self):\n # get the summary data\n options = { 'PayLoadText' : self.payments_request_xml() }\n\n response = request.get(self.url, params=options) \\\n .text\n print(response)","def custom_assess_status_check(self):\n options = self.options\n # can check options.thing to ensure that it makes sense\n # if wrong return 'blocked', \"The driver is badly configured ...\"\n return None, None","def check_account_status(request):\n\n user = request.user\n\n if not user.is_authenticated():\n return {\n 'current_user': user,\n 'check_account_status_url': reverse('check_account_status'),\n }\n\n session = request.session\n\n flag = session.get('show_email_confirmation_dialog', True)\n show = not user.has_activated_account and flag\n session['show_email_confirmation_dialog'] = False\n\n # We don't want so show email confirmation when use is trying to buy a ticket.\n if 'payment-details' in request.path:\n show = False\n\n return {\n 'current_user': user,\n 'show_email_confirmation_dialog': False,\n 'check_account_status_url': reverse('check_account_status'),\n }","def m_apiInstance_ConnectionStatusUpdate(self, sender, e):\r\n if e.Status.IsSuccess:\r\n # Add code here to begin working with the TT API\r\n # lookup an instrument\r\n self.m_req = ttapi.InstrumentLookupSubscription(self.m_apiInstance.Session, ttapi.Dispatcher.Current, ttapi.ProductKey(ttapi.MarketKey.Cme, ttapi.ProductType.Future, \"6J\"), \"Dec17\")\r\n self.m_req.Update += self.m_req_Update\r\n print(\"Connection Success!\")\r\n self.m_req.Start()\r\n else:\r\n print(\"TT Login failed: {0}\".format(e.Status.StatusMessage))\r\n self.Dispose()","def policy_checker(name):\n\n policy = PolicyModel.query(PolicyModel.Name == name).get()\n if not policy:\n logging.error(\"Policy %s not found!\", name)\n return \"not found\", 404\n schedule = SchedulesModel.query(SchedulesModel.Name == policy.Schedule).get()\n if not schedule:\n logging.error(\"Schedule %s not found!\", policy.Schedule)\n return \"not found\", 404\n logging.debug(\n \"Time at Timezone %s is %s\",\n schedule.Timezone,\n tz.get_time_at_timezone(schedule.Timezone),\n )\n day, hour = tz.convert_time_to_index(tz.get_time_at_timezone(schedule.Timezone))\n logging.debug(\"Working on day %s hour %s\", day, hour)\n arr = np.asarray(schedule.Schedule[\"__ndarray__\"], dtype=np.int).flatten()\n matrix_size = schedule.Schedule[\"Shape\"][0] * schedule.Schedule[\"Shape\"][1]\n prev = utils.get_prev_idx(day * 24 + hour, matrix_size)\n now = arr[day * 24 + hour]\n prev = arr[prev]\n logging.info(\"Previous state %s current %s\", prev, now)\n if now == prev:\n # do nothing\n logging.info(\"Conditions are met, Nothing should be done for %s\", name)\n return \"ok\", 200\n else:\n # stop/start\n logging.info(\"State is changing for %s to %s\", name, now)\n # for each tag lets do it\n\n task_client = tasks_v2.CloudTasksClient()\n task = {\n \"app_engine_http_request\": { # Specify the type of request.\n \"http_method\": \"POST\",\n \"relative_uri\": \"/tasks/change_state\",\n }\n }\n parent = task_client.queue_path(\n queue=\"zorya-tasks\",\n project=utils.get_project_id(),\n location=location.get_location(),\n )\n for tag in policy.Tags:\n for project in policy.Projects:\n payload = {\n \"project\": project,\n \"tagkey\": next(iter(tag)),\n \"tagvalue\": tag[next(iter(tag))],\n \"action\": str(now),\n }\n task[\"app_engine_http_request\"][\"body\"] = (\n json.dumps(payload)\n ).encode()\n response = task_client.create_task(parent, task)\n logging.debug(\"Task %s enqueued\", response.name)\n return \"ok\", 200","def payment_success(request):\r\n\tsecret_key = settings.SELLER_KEY\r\n\tpid = request.GET['pid']\r\n\tref = request.GET['ref']\r\n\tresult = request.GET['result']\r\n\t# Retrieve the cheksum value and validate it\r\n\tchecksumstr = \"pid={}&ref={}&result={}&token={}\".format(pid, ref, result, secret_key)\r\n\tm = md5(checksumstr.encode(\"ascii\"))\r\n\tchecksum = m.hexdigest()\r\n\tmalformed = False\r\n\tprint(\"calculated: \" + checksum)\r\n\tprint(\"received: \" + request.GET['checksum'] )\r\n\tif (checksum == request.GET['checksum'] ):\r\n\t\ttransaction = Transaction.objects.get(pk=pid)\r\n\t\ttransaction.state = Transaction.CONFIRMED\r\n\t\ttransaction.reference = ref\r\n\t\tgame = Game.objects.get(id = transaction.game.id)\r\n\t\ttransaction.save()\r\n\t\tinc_purchase = game.purchase_number + 1\r\n\t\tgame.purchase_number = inc_purchase\r\n\t\tgame.save()\r\n\t\tprint(\"about to call success\")\r\n\t\treturn render(request, 'success.html', {'game': game, 'MEDIA_URL': settings.MEDIA_URL, 'malformed': malformed})\r\n\telse:\r\n\t\ttransaction = Transaction.objects.get(pk=pid)\r\n\t\ttransaction.delete()\r\n\t\tmalformed = True\r\n\t\treturn render(request, 'success.html', {\"malformed\": malformed})","def verify(self, request):\n paypalURL = 'https://www.sandbox.paypal.com/cgi-bin/webscr'\n if not self.SANDBOX:\n paypalURL = 'https://www.paypal.com/cgi-bin/webscr'\n\n def _cb(response):\n if response == 'INVALID':\n raise PaypalError(\n 'IPN data invalid. data: %s', (data,))\n\n elif response == 'VERIFIED':\n return True\n\n else:\n raise PaypalError('Unrecognized verification response: %s', (response,))\n\n data = request.content.read()\n params = '?cmd=_notify-validate&' + data\n\n d = getPage(paypalURL+params, method='POST')\n d.addCallback(_cb)\n return d","def __get_payment_details(self, token, PayerID):\n request_params = {\n 'METHOD': GET_CHECKOUT,\n 'TOKEN': token,\n }\n\n response = self.__do_request(request_params)\n\n if response['ACK'] == RESPONSE_OK:\n return self.__capture_payment(response)\n\n return redirect(url_for('payment.error_payment',\n payment_method=self.method_name))","def test_process_postpay_accepted(self):\r\n student1 = UserFactory()\r\n student1.save()\r\n\r\n order1 = Order.get_cart_for_user(student1)\r\n params = {\r\n 'card_accountNumber': '1234',\r\n 'card_cardType': '001',\r\n 'billTo_firstName': student1.first_name,\r\n 'orderNumber': str(order1.id),\r\n 'orderCurrency': 'usd',\r\n 'decision': 'ACCEPT',\r\n 'ccAuthReply_amount': '0.00'\r\n }\r\n result = process_postpay_callback(params)\r\n self.assertTrue(result['success'])\r\n self.assertEqual(result['order'], order1)\r\n order1 = Order.objects.get(id=order1.id) # reload from DB to capture side-effect of process_postpay_callback\r\n self.assertEqual(order1.status, 'purchased')\r\n self.assertFalse(result['error_html'])","def test_postflight_page_status(self):\n response = self.client.get('/postflight/')\n self.assertEqual(response.status_code, 200)","def verify_payment(self, order_id, ref_id):\n try:\n client = Client(self.service_address)\n res = client.service.bpVerifyRequest(terminalId=self.terminalId,\n userName=self.userName,\n userPassword=self.userPassword,\n orderId=order_id,\n saleOrderId=order_id,\n saleReferenceId=ref_id)\n return True, res\n except WebFault as f:\n return False, f.fault.faultstring\n except Exception as e:\n return False, e.message","def checkState(self, desiredPage):\n try:\n # page = self.driver.find_elements_by_tag_name(\"h1.title\")\n page = self.driver.find_element(\n By.XPATH, \"/html/body/main/section/section/div[1]/h1\").text\n page = str(page)\n page = page.lower()\n\n if (desiredPage == \"watchlist\"):\n if (page == \"transfer targets\"):\n return True\n else:\n log_event(\n self.queue, \"Unexpectedly not on Watchlist, stopping\")\n return False\n\n elif (desiredPage == \"transfermarket\"):\n if (page == \"search results\"):\n return True\n else:\n log_event(\n self.queue, \"Unexpectedly not on Transfer Market, stopping\")\n return False\n\n elif (desiredPage == \"transferlist\"):\n if (page == \"transfer list\"):\n return True\n else:\n log_event(\n self.queue, \"Unexpectedly not on Transfer list, stopping\")\n return False\n else:\n log_event(self.queue, \"checkState was passed invalid location\")\n except:\n log_event(self.queue, \"Error checking state\")","def check_validity(request_id):\n return {\n \"action\": \"PAYMENT_ACCEPTED\",\n \"message\": {\n \"status\": \"OK\",\n \"request\": int(request_id)\n }\n }","def get_razorpay_transaction_status(transaction_id):\n global RazorPayClient\n return RazorPayClient.order.fetch(transaction_id)['status']","def test_successful_create_payment_payu_pln(self):\n order = Order(name='Test PLN order', total=100, currency='PLN')\n order.save()\n response = self.client.post(reverse('getpaid-new-payment', kwargs={'currency' : 'PLN'}),\n {'order': order.pk,\n 'backend': 'getpaid.backends.payu'}\n )\n self.assertEqual(response.status_code, 302)\n Payment = get_model('getpaid', 'Payment')\n payment = Payment.objects.get(order=order.pk)\n self.assertEqual(payment.backend, 'getpaid.backends.payu')\n self.assertEqual(payment.amount, order.total)\n self.assertEqual(payment.currency, order.currency)\n self.assertEqual(payment.status, 'in_progress')\n self.assertEqual(payment.paid_on, None)\n self.assertEqual(payment.amount_paid, 0)","def get_site_status(url):\n repCode=None\n\n if url is \"\":\n return(\"Not Valid\")\n\n try:\n t1 = datetime.now()\n response = get_response(url)\n t2 = datetime.now()\n\n elapsed = t2-t1\n\n retTime = elapsed.microseconds\n\n repCode = getattr(response, 'status')\n\n logResponse(url,repCode,\"\",str(retTime))\n\n if repCode == 200:\n return 'up'\n except Exception as e:\n logResponse(url,repCode,e)\n pass\n return 'down'","def test_specific_peer_status(self):\n ps2_status = self.pybird.get_peer_status(\"PS2\")\n self.assertTrue(ps2_status['up'])\n\n # The test data says 14:20, so that could be today or yesterday\n now = datetime.now()\n expected_date = datetime(now.year, now.month, now.day, 14, 20)\n if now.hour < 14 or now.hour == 14 and now.minute < 20:\n expected_date = expected_date - timedelta(days=1)\n self.assertEquals(ps2_status['last_change'], expected_date)\n\n self.assertEquals(ps2_status['state'], \"Established\")\n self.assertEquals(ps2_status['routes_imported'], 24)\n self.assertEquals(ps2_status['routes_exported'], 23)\n self.assertEquals(ps2_status['import_updates_received'], 12)\n self.assertEquals(ps2_status['import_withdraws_accepted'], 3)\n self.assertEquals(ps2_status['export_updates_rejected'], 12)\n self.assertEquals(ps2_status['router_id'], \"85.184.4.5\")\n\n ps1_status = self.pybird.get_peer_status(\"PS1\")\n self.assertFalse(ps1_status['up'])\n\n self.assertEquals(ps1_status['last_change'], datetime(now.year, 6, 13))\n\n self.assertEquals(ps1_status['state'], \"Passive\")","def alert_for_pending_invoices_1(request):\n\n\tprint(\">>>>>>>>>>>>>>>>>>>>>Beginning of alert_for_pending_invoices_1<<<<<<<<<<<<<<<<<<<<\")\n\n\tThread(target=alert_for_pending_invoices_1_woker).start()\n\n\tprint(\">>>>>>>>>>>>>>>>>>>>>End of alert_for_pending_invoices_1<<<<<<<<<<<<<<<<<<<<\")\n\n\tresponse = {}\n\n\tresponse[\"info_to_contact\"] = \"Ok\"\n\n\treturn response","def check_new_payment_authcode(self, request: HttpRequest):\n return self.check_authcode_params(\n request,\n (\n \"RETURN_CODE\",\n \"ORDER_NUMBER\",\n \"SETTLED\",\n \"CONTACT_ID\",\n \"INCIDENT_ID\",\n ),\n )","def update_payment_status(payment):\n _assert_payment_is_yandex_kassa(payment)\n yk_payment = api.get_payment_by_id(payment.gateway_payment_id)\n _update_payment_status(payment, yk_payment)","def get_gateway_url(self, request):\n params = {\n 'id': self.get_backend_setting('id'),\n 'description': self.get_order_description(self.payment, self.payment.order),\n 'amount': self.payment.amount,\n 'currency': self.payment.currency,\n 'type': 0, # 0 = show \"return\" button after finished payment\n 'control': self.payment.pk,\n 'URL': self.get_URL(self.payment.pk),\n 'URLC': self.get_URLC(),\n 'api_version': 'dev',\n }\n\n user_data = {\n 'email': None,\n 'lang': None,\n }\n signals.user_data_query.send(sender=None, order=self.payment.order, user_data=user_data)\n\n if user_data['email']:\n params['email'] = user_data['email']\n\n if user_data['lang'] and user_data['lang'].lower() in self._ACCEPTED_LANGS:\n params['lang'] = user_data['lang'].lower()\n elif self.get_backend_setting('lang', False\n ) and self.get_backend_setting('lang').lower() in self._ACCEPTED_LANGS:\n params['lang'] = self.get_backend_setting('lang').lower()\n\n if self.get_backend_setting('onlinetransfer', False):\n params['onlinetransfer'] = 1\n if self.get_backend_setting('p_email', False):\n params['p_email'] = self.get_backend_setting('p_email')\n if self.get_backend_setting('p_info', False):\n params['p_info'] = self.get_backend_setting('p_info')\n if self.get_backend_setting('tax', False):\n params['tax'] = 1\n\n gateway_url = self.get_backend_setting('gateway_url', self._GATEWAY_URL)\n\n if self.get_backend_setting('method', 'get').lower() == 'post':\n return gateway_url, 'POST', params\n elif self.get_backend_setting('method', 'get').lower() == 'get':\n for key in params.keys():\n params[key] = six.text_type(params[key]).encode('utf-8')\n return gateway_url + '?' + urlencode(params), \"GET\", {}\n else:\n raise ImproperlyConfigured('Dotpay payment backend accepts only GET or POST')","def onCheckout(self, controller):\n \n if askokcancel(\"Proceed\", \"Pay the order?\"):\n c = controller.customer\n package = {'customer_id':c.id, 'order_price':c.my_order.GetTotalPrice}\n msg = controller.transmit(package)\n \n if msg['order_received']:\n c.CheckOut(c.my_order.GetTotalPrice)\n c.Clear()\n controller.show_frame(PageThree)","def test_successful_create_payment_payu_pln(self):\n order = Order(name='Test PLN order', total=100, currency='PLN')\n order.save()\n response = self.client.post(reverse('getpaid-new-payment', kwargs={'currency': 'PLN'}),\n {'order': order.pk,\n 'backend': 'getpaid.backends.payu'}\n )\n self.assertEqual(response.status_code, 302)\n Payment = apps.get_model('getpaid', 'Payment')\n payment = Payment.objects.get(order=order.pk)\n self.assertEqual(payment.backend, 'getpaid.backends.payu')\n self.assertEqual(payment.amount, order.total)\n self.assertEqual(payment.currency, order.currency)\n self.assertEqual(payment.status, 'in_progress')\n self.assertEqual(payment.paid_on, None)\n self.assertEqual(payment.amount_paid, 0)","def accept_license():\r\n msg, status = \"\", True\r\n\r\n try:\r\n sleep(5)\r\n if g.platform == 'android':\r\n sleep(3)\r\n 'Click on license accept button'\r\n flag1 = ui_controls.button(get_obj_identifier('license_accept_btn'))\r\n \r\n \r\n\r\n status = False if not (flag1) else True\r\n else:\r\n \r\n 'Click on Agree button in EULA page for IOS'\r\n flag = ui_controls.button(get_obj_identifier('license_accept_btn'))\r\n status = flag\r\n\r\n except Exception as excp:\r\n traceback.print_exc()\r\n msg += str(excp)\r\n status = False\r\n\r\n return status, msg","def paypal_gateway(self):\n\n print(request.form)\n\n # Gather information from callback response\n first_name = request.form.get(\"first_name\", None)\n last_name = request.form.get(\"last_name\", None)\n payer_id = request.form.get(\"payer_id\", None)\n payer_email = request.form.get(\"payer_email\", None)\n item_name = request.form.get(\"item_name\", None)\n item_number = request.form.get(\"item_number\", None)\n custom = request.form.get(\"custom\", None)\n payment_gross = request.form.get(\"payment_gross\", None)\n\n ## Generate Token and store in database\n gen_uuid = str(uuid.uuid4())\n\n try:\n t = Token()\n t.uuid = gen_uuid\n t.email = payer_email\n t.active = True\n t.package = item_name\n t.package_id = item_number\n\n db.session.add(t)\n db.session.commit()\n except:\n import traceback\n db.session.rollback()\n traceback.print_exc()\n\n ## Send email to user with unique link\n try:\n msg = Message(\n \"Guildbit - Order Confirmation\",\n sender=settings.DEFAULT_MAIL_SENDER,\n recipients=[payer_email])\n\n msg.html = render_template(\"emails/payment_thankyou.html\", package=item_name, uuid=gen_uuid)\n mail.send(msg)\n except:\n import traceback\n traceback.print_exc()\n\n return jsonify({\n \"status\": \"received\"\n })","def waiting_confirmation(self):","def checkout(driver, user_details) -> None:\n\t\n\t# wait until checkout page loads\n\ttry: # look for twitter button as indicator of load\n\t\twait = WebDriverWait(driver, 10)\n\t\telement = wait.until(EC.element_to_be_clickable(\n\t\t\t(By.XPATH, \"//a[@href='https://twitter.com/tendmoney']\")))\n\texcept NoSuchElementException: # page didn't load in a reasonable amount of time\n\t\tmanual_takeover() # swap to manual mode\n\t# fill out checkout details\n\tdriver.find_element_by_id(\"billing_first_name\").send_keys(user_details[0]) # first name\n\tdriver.find_element_by_id(\"billing_last_name\").send_keys(user_details[1]) # last name\n\tdriver.find_element_by_id(\"ak_venmo\").send_keys(user_details[2]) # venmo username\n\tdriver.find_element_by_id(\"billing_email\").send_keys(user_details[3]) # email address\n\t# switch to popup/new page (https://stackoverflow.com/a/29052586/4513452)\n\t# try: # look for clear cart button as indicator of load\n\t# \twait = WebDriverWait(driver, 15)\n\t# \t# not working even though i swear it's right\n\t# \t# element = wait.until(EC.element_to_be_clickable(\n\t# \t# \t(By.XPATH, '/html/body/div[1]/div/div[1]/div')))\n\t# \telement = wait.until(EC.element_to_be_clickable(\n\t# \t\t(By.XPATH, \"//a[contains(text(), 'Clear Cart')]\")))\n\t# except: # page didn't load in a reasonable amount of time\n\t# \tmanual_takeover() # swap to manual mode\n\t# driver.find_element_by_xpath('/html/body/div[1]/div/div[1]/div').click() # click pay\n\ttime.sleep(10) # i have no idea why this ^ shit doesn't work, f this\n\t# this is so janky lol don't tell anyone\n\tdriver.find_element_by_id(\"billing_email\").click() # click email address\n\tdriver.find_element_by_id(\"billing_email\").send_keys(Keys.TAB) # tab over to paypal\n\tActionChains(driver).key_down(Keys.RETURN).key_up(Keys.RETURN).perform() # hit enter\n\t# driver.find_element_by_xpath(\"/html\").send_keys(Keys.RETURN) # hit enter on paypal\n\ttime.sleep(10)\n\t# try: # look for overlay as indicator of load\n\t# \twait = WebDriverWait(driver, 15)\n\t# \telement = wait.until(EC.element_to_be_clickable(\n\t# \t\t(By.XPATH, \"//a[contains(text(), 'Click to Continue')]\")))\n\t# except: # page didn't load in a reasonable amount of time\n\t# \tmanual_takeover() # swap to manual mode\n\tmain_window_handle = driver.window_handles[0] # get main window handle for later\n\tpaypal_window_handle = driver.window_handles[1] # get paypal popup handle\n\t# print(\"pp handle: \", paypal_window_handle)\n\tdriver.switch_to.window(paypal_window_handle) # focus on popup\n\ttry: # look for final payment button as indicator of load\n\t\twait = WebDriverWait(driver, 25)\n\t\telement = wait.until(EC.element_to_be_clickable(\n\t\t\t(By.ID, \"payment-submit-btn\")))\n\texcept NoSuchElementException: # page didn't load in a reasonable amount of time\n\t\tmanual_takeover() # swap to manual mode\n\t# testing\n\t# pp = driver.find_element_by_id(\"payment-submit-btn\") # .click()\n\t# print(\"pp: \", pp) # dont want to actually check out during testing\n\t# real checkout\n\tdriver.find_element_by_id(\"payment-submit-btn\").click()","def payment_confirmation(self, **post):\n sale_order_id = view.session.get('sale_last_order_id')\n partner_id = view.env.user.partner_id\n if sale_order_id:\n sale_order_id = view.env['sale.order'].sudo().browse(int(sale_order_id))\n lines = sale_order_id.order_line\n policy_line = view.env['policies.holder.line']\n for line in lines:\n code = ''.join(random.choice('0123456789ABCDEF') for i in range(16))\n policy_line.sudo().create({'name':lines.product_id.id, \n 'premium':lines.price_unit, \n 'policy_code':code, \n 'line_id':partner_id.id,\n 'start_date':Datetime.now(), 'end_date':Datetime.to_string(timedelta(days=lines.product_id.policy_period*360)+ datetime.now())})\n s = super(InsuranceWebsiteSale, self).payment_confirmation()\n view.session['sale_last_order_id'] = False\n return s\n return","def trail_balance(self, pk, request):\n try:\n # Checking Token Authentication available\n auth_info = AccountingOauth2.objects.filter(company_id=pk).values('accessToken', 'accessSecretKey',\n 'tokenAcitvatedOn', 'tokenExpiryON')\n secret_keys = Utils.get_access_keys(pk)\n if len(auth_info) == 0:\n return Utils.dispatch_failure(request, \"NO_TOKEN_AUTHENTICATION\")\n\n for key, value in auth_info[0].items():\n OAUTH_PERSISTENT_SERVER_STORAGE.update({key: value})\n stored_values = OAUTH_PERSISTENT_SERVER_STORAGE\n\n if len(stored_values) == 0:\n return Utils.dispatch_failure(request, \"NO_TOKEN_AUTHENTICATION\")\n\n\n # Checking Xero Connection Authentication available\n auth = Utils.get_xero_auth(pk)\n\n if AccountingConfiguration.PRIVATE == secret_keys.type:\n credentials = PrivateCredentials(**auth)\n else:\n credentials = PublicCredentials(**auth)\n\n if credentials.expired() or credentials is None:\n return Utils.dispatch_failure(request, \"NO_TOKEN_AUTHENTICATION\")\n\n try:\n xero = Xero(credentials)\n xero.reports.get('TrialBalance')\n\n except XeroException as e:\n if AccountingConfiguration.PRIVATE == secret_keys.type:\n error = [\"%s\" % e]\n return Utils.dispatch_failure(request, 'XERO_CONNECTION_ERROR', error)\n else:\n return Utils.dispatch_failure(request, \"NO_TOKEN_AUTHENTICATION\")\n try:\n meta = CompanyMeta.objects.filter(company_id=pk).first()\n if meta.monthly_reporting_current_period:\n st = time.time()\n from portalbackend.lendapi.v1.accounting.tasks import trial_balance_for_period\n job = group(trial_balance_for_period.s(pk, i) for i in range(0, 23))\n result = job.apply_async()\n else:\n return Utils.dispatch_failure(request, 'MISSING_MONTHLY_REPORTING_CURRENT_PERIOD')\n\n while not result.ready():\n continue\n return Utils.dispatch_success(request, 'TRIAL_BALANCE_RECEIVED_SUCCESS')\n except Exception as e:\n error = [\"%s\" % e]\n return Utils.dispatch_failure(request, 'DATA_PARSING_ISSUE', error)\n except Exception as e:\n return Utils.dispatch_failure(request, \"INTERNAL_SERVER_ERROR\")","def payment(request,game_id):\r\n\tgame = Game.objects.get(id = game_id)\r\n\tif(game is not None): #check if the game exists\r\n\t\tcheck_if_bought = Transaction.objects.filter(payer = request.user.profile,game=Game.objects.get(id=game_id),state=Transaction.CONFIRMED).count() #check if user has already purchased the game\r\n\t\tif check_if_bought > 0 or game.developer == request.user.profile:\r\n\t\t\treturn redirect(\"/play/\" + str(game_id))\r\n\t\tpurchase_game = Game.objects.get(id = game_id)\r\n\t\tnew_payer = Profile.objects.get(user = request.user)\r\n\t\tnew_payee= purchase_game.developer\r\n\t\ttransaction = Transaction.objects.create(payer=new_payer, payee= new_payee, game=purchase_game,amount=purchase_game.price)\r\n\t\ttransaction.save()\r\n\t\t# Generate checksum and hash values\r\n\t\tchecksumstr = \"pid={}&sid={}&amount={}&token={}\".format(transaction.id, settings.SELLER_ID, purchase_game.price, settings.SELLER_KEY)\r\n\t\tm = md5(checksumstr.encode(\"ascii\"))\r\n\t\tchecksum = m.hexdigest()\r\n\r\n\t\tprint(transaction.id, transaction.state, checksumstr)\r\n\t\treturn render(request, 'payment.html', {'game':purchase_game,'SELLER_ID':settings.SELLER_ID, 'MEDIA_URL': settings.MEDIA_URL, 'transaction': transaction, 'checksum': checksum})\r\n\telse:\r\n\t\treturn redirect('home') # Redirect to home if link is faulty\r","def check(self):\n\n print('Requester object is active: \\t', str(self.is_active))\n print('Number of requests sent: \\t', str(self.n_requests))\n print('Requester opened: \\t\\t', str(self.st_time))\n print('Requester closed: \\t\\t', str(self.en_time))","def get_status(self):\n\t\treturn call_sdk_function('PrlLic_GetStatus', self.handle)","def test_list_scheduled_payments(self):\n pass","def update_paypal(sender, **kwargs):\n ipn_obj = sender\n try:\n payment = json.loads(ipn_obj.custom)\n\n # try to get payment. if not exist, exception will be catched\n p = Payment.objects.filter(id=payment.get('id'), token=payment.get('token')).get()\n\n # update payment\n p.method = constants.PAYPAL\n p.ipn = ipn_obj\n p.save()\n\n # if payment is completed, so valid\n if ipn_obj.payment_status == ST_PP_COMPLETED:\n # check correct price , currency and mail\n if int(ipn_obj.mc_gross) == int(p.price.price) and \\\n ipn_obj.mc_currency == 'EUR' and \\\n ipn_obj.business == settings.PAYPAL_RECEIVER_EMAIL:\n # all is OK, update state\n p.state = True\n p.save()\n sendmail_payment_success(p)\n else:\n # TODO: send alert / mail\n return\n except Payment.DoesNotExist:\n # TODO: send alert / mail\n pass\n except:\n # TODO: send alert / mail\n pass","def pp_confirm_payment_interactive(self, approval_url):\n from selenium import webdriver\n from selenium.webdriver.common.keys import Keys\n display = Display(visible=0, size=(800,600))\n display.start()\n br = webdriver.Firefox()\n br.get(approval_url)\n e = br.find_element_by_id('loadLogin')\n e.click()\n e = br.find_element_by_id('login_email')\n e.send_keys(settings.PAYPAL_TESTUSER)\n e = br.find_element_by_id('login_password')\n e.send_keys(settings.PAYPAL_TESTUSER_PASSWORD)\n e = br.find_element_by_id('submitLogin')\n e.click()\n e = br.find_element_by_id('continue')\n e.click()\n # response url is of the form\n # http://<return_url>?paymentId=PAY-6RV70583SB702805EKEYSZ6Y&token=EC-60U79048BN7719609&PayerID=7E7MGXCWTTKK2\n # see https://developer.paypal.com/docs/integration/web/accept-paypal-payment/#get-payment-approval\n response_url = br.current_url\n parts = urlparse.urlparse(response_url)\n authorization = urlparse.parse_qs(parts.query)\n br.get_screenshot_as_file('payment.png')\n br.quit()\n display.stop()\n return authorization","def paynova_callback(request):\n\n log.info('Callback. %s ' % request.POST)\n\n # check DIGEST\n\n if not _ehn_checksum(request.POST):\n log.error('EHN DIGEST hash is not verified. %s' % request.POST)\n return HttpResponseBadRequest()\n\n # check EVENT_TYPE\n # TODO: process other events\n\n if request.POST.get('EVENT_TYPE') != 'PAYMENT':\n log.error('Unexpected EVENT_TYPE. %s' % request.POST)\n return HttpResponseBadRequest()\n\n # get PaynovaPayment from model\n\n try:\n pp = PaynovaPayment.objects.get(order_id=request.POST.get('ORDER_ID'), session_id=request.POST.get('SESSION_ID'))\n except PaynovaPayment.DoesNotExist:\n log.error('Unknown ORDER_ID. %s' % request.POST)\n return HttpResponseNotFound()\n\n pp.status = request.POST.get('PAYMENT_STATUS')\n pp.status_reason = request.POST.get('PAYMENT_STATUS_REASON')\n pp.params_ehn = request.POST\n pp.save()\n\n # send signal\n\n log.debug('Process paynova_payment signal')\n\n paynova_payment.send(sender=pp, params=request.POST, status=request.POST.get('PAYMENT_STATUS'))\n\n log.debug('Signal paynova_payment processed')\n\n return HttpResponse()","def _verify_page(self):","def order_success(request, job_id, token):\n if request.user.is_active:\n job_obj = Job.objects.get(job_id= job_id)\n if job_obj.employeer == request.user:\n if verifiers.payment_token_is_valid(token, job_obj):\n if job_obj.accepted == False:\n job_obj.status = Status.objects.create(status_name=\"PN\", comment=\"Awaiting payment confirmation from Stripe, this might take a few minutes.\")\n job_obj.accepted = True\n job_obj.save()\n \n messages.add_message(request, messages.INFO, 'Your order has been created.')\n return redirect('/') \n else:\n #someone tries to manually enter the URL with wrong payment_token\n messages.add_message(request, messages.INFO, 'Something went wrong, try again later.') \n return redirect(\"/\") \n else:\n #the person making the request is not the same as the person who created the job\n messages.add_message(request, messages.INFO, 'Something went wrong, try again later.') \n return redirect(\"/\") \n else:\n return redirect(\"/login\")","def click_submit_payment_button(self):\n self.click(self.submit_payment_locator)\n time.sleep(2)","async def verify(self, payee, paid_for, guild_id, amount, message_id):\n\n collection = self.db[str(guild_id)]\n\n payee_doc = await collection.find_one({'id': payee.id})\n paid_for_doc = await collection.find_one({'id': paid_for.id})\n values = payee_doc['data']\n paid_for_values = paid_for_doc['data']\n if not self.unapproved(paid_for_doc, message_id):\n return\n\n if list(values.keys()).count(str(paid_for.id)) > 0:\n values[str(paid_for.id)] = values[str(paid_for.id)] + amount\n else:\n values[str(paid_for.id)] = amount\n\n '''Adding payment in paid_for's collection'''\n\n if list(paid_for_values.keys()).count(str(payee.id)) > 0:\n paid_for_values[str(payee.id)] = paid_for_values[str(payee.id)] - amount\n else:\n paid_for_values[str(payee.id)] = - amount\n\n await collection.update_one({'id': paid_for.id}, {'$set': {'data': paid_for_values}})\n\n '''Adding payment in payee's collection'''\n await collection.update_one({'id': payee.id}, {'$set': {'data': values}})\n\n \"\"\"Decreasing value of left verifications from DB\"\"\"\n unverified = payee_doc['unverified']\n verified = None\n for message in unverified:\n if message['Mid'] == message_id:\n verified = message\n break\n if verified['left'] == 1:\n unverified.remove(verified)\n else:\n verified['left'] -= 1\n\n await collection.update_one({'id': payee.id}, {'$set': {'unverified': unverified}})\n\n \"\"\"Removing unapproved from paid_for's DB\"\"\"\n unapproved = paid_for_doc['unapproved']\n approved = None\n for message in unapproved:\n if message['Mid'] == message_id:\n approved = message\n break\n\n unapproved.remove(approved)\n await collection.update_one({'id': paid_for.id}, {'$set': {'unapproved': unapproved}})","def status():\n\n header(title=\"Site Status\", domain_name=domain_name)\n\n if not client.site_exists:\n site_404_message(config.get(\"domain\"))\n footer()\n return\n\n print(\"---\")\n print(\"URL : %s \" % client.domain_url)\n \n print(\"---\")\n print(\"S3\")\n print(\"Site created: %s \" % ('OK' if client.site_exists else 'Failed'))\n print(\"URL : %s \" % client.s3_url)\n\n if distribution != \"s3\":\n print(\"---\")\n print(\"ACM\")\n print(\"Certificate status: %s \" % client.acm_get_certificate_status())\n\n print(\"---\")\n print(\"Cloudfront\")\n print(\"Distribution id: %s \" % client.cloudfront_get_distribution_id())\n print(\"Domain name: %s \" % client.cloudfront_get_distribution_domain_name())\n\n ns_values = client.route53_get_ns_values()\n if ns_values:\n print(\"---\")\n print(\"Name Servers\")\n print((\"\\n\".join(ns_values)))\n else:\n print(\"Deployment: site is available from AWS S3 only\")\n footer()","def _update_payment_status(payment: Payment, yk_payment: PaymentResponse):\n _assert_payment_is_yandex_kassa(payment)\n\n mapped_status = _YK_STATUS_MAPPING.get(yk_payment.status)\n assert mapped_status, \\\n f'Cannot map status {yk_payment.status} for {yk_payment}'\n\n # float because of https://github.com/yandex-money/yandex-checkout-sdk-python/pull/64\n yk_amount = float(yk_payment.amount.value)\n yk_currency = yk_payment.amount.currency\n payment_amount = float(payment.amount.amount)\n payment_currency = payment.amount.currency.code\n\n # Let's find out if there are some updates\n need_save = False\n if yk_amount != payment_amount:\n logger.error(f'Incorrect amount {payment_amount} in Payment. Correcting it to {yk_amount}')\n payment.amount = Money(yk_amount, yk_currency)\n need_save = True\n if yk_currency != payment_currency:\n logger.error(f'Incorrect currency {payment_currency} in Payment. Correcting it to {yk_currency}')\n payment.amount = Money(yk_amount, yk_currency)\n need_save = True\n\n if payment.state != mapped_status:\n payment.state = mapped_status\n need_save = True\n\n if need_save:\n logger.info(f'Updating payment {payment}')\n payment.save()\n else:\n logger.debug(f'No need to update {payment}')","def verify(self, response):","def test_get_virtual_account_payments(self):\n pass","def verify_farmer_payment(self, payment_id, pay_status):\n if not self.this_user:\n return self.return_data(401, \"Current user not set\", {})\n\n payment_info = self.get_a_payment(payment_id)\n loan_owner = {}\n if payment_info:\n loan_owner = self.get_loan_owner(payment_info[\"loan_id\"])\n is_incharge = False\n is_manager = False\n if len(loan_owner) > 0:\n is_incharge = self.is_farmers_agent(\n self.this_user[\"username\"], loan_owner[\"username\"]\n )\n if self.this_user[\"role\"] == \"CREDIT_MANAGER\":\n is_manager = True\n\n if (is_incharge or is_manager):\n q_list = []\n query = self.update_query(\n \"payments\", \"approved\", pay_status,\n \"payment_id\", payment_id\n )\n q_list.append(query)\n reply = self.save_data(q_list)\n if isinstance(reply, bool):\n reply = self.get_a_payment(payment_id)\n reply[\"amount_paid\"] = str(reply[\"amount_paid\"])\n return self.return_data(200, \"SUCCESS\", reply)\n return self.return_data(400, \"BAD REQUEST\", reply)\n return self.return_data(401, \"UNAUTHRIZED\", {})","def make_payment():\n\n response = VoiceResponse()\n if 'caller_name' not in session:\n session['caller_name'] = request.args.get(\n 'caller_name') or \"Twilio Payment\"\n if 'payment_amount' not in session:\n session['payment_amount'] = request.args.get('amount') or \"5000\"\n if 'card_number' not in session:\n response.redirect('/get_card_number')\n elif 'expiry' not in session:\n response.redirect('/get_expiry')\n elif 'cvv' not in session:\n response.redirect('/get_cvv')\n else:\n call_sid = request.form.get('CallSid')\n session['call_sid'] = call_sid\n response.redirect('/process_payment')\n\n return str(response)","def remote_status():","def post(self, payment_id=None):\n data = request.get_json()\n redirect_url = data.get('redirect_url')\n cart_token = data.get('cart_token')\n address_id = data.get('address_id')\n \n cart = Cart.query.filter_by(token=cart_token, user_id=current_user.id).first()\n if not cart:\n return {\"message\":\"No cart with this id\"}, 404\n\n if not address_id:\n return {\"message\": \"Please enter a address for your order\"}, 404\n\n order = Order.create_from_cart(cart_token, address_id)\n payment = Payment.query.filter_by(order_id=order.id).first()\n if not payment:\n payment = Payment(\n user_id=current_user.id, \n order_id=order.id, \n amount=order.total,\n status='Pending'\n )\n\n db.session.add(payment)\n db.session.commit()\n\n client = Client(current_app.config['ZARINPAL_WEBSERVICE'])\n mail = current_user._email\n\n if not mail:\n return {\"message\": \"Please enter your email address to continue the payment\"}\n\n user_info = UserAddress.query.filter_by(id=address_id).first()\n if user_info.phone:\n mobile = user_info.phone\n else:\n mobile = '' \n\n result = client.service.PaymentRequest(current_app.config['MERCHANT_ID'],\n payment.amount,\n 'nani',\n mail,\n mobile,\n redirect_url)\n\n payment.authority = result.Authority\n db.session.commit()\n if result.Status == 100:\n return {'payment_url':'https://www.zarinpal.com/pg/StartPay/' + result.Authority}\n else:\n return {\n 'message':\"We can't connect you to zarin pal server, right now. Please try again in a few moments.\"\n }, 404","def you_win(request):\n # filter originals by paid is false and auction is closed\n now = datetime.now()\n auction_items_to_be_paid = Original.objects.exclude(end_date_time__lte=now, paid=\"True\")\n if not auction_items_to_be_paid:\n redirect(reverse(originals)) \n # if it is empty, then redirect to auctions.html\n\n return render(request, 'youwin.html', { 'auction_items_to_be_paid': auction_items_to_be_paid })","def process_postpay_callback(params):\r\n try:\r\n verify_signatures(params)\r\n result = payment_accepted(params)\r\n if result['accepted']:\r\n # SUCCESS CASE first, rest are some sort of oddity\r\n record_purchase(params, result['order'])\r\n return {'success': True,\r\n 'order': result['order'],\r\n 'error_html': ''}\r\n else:\r\n return {'success': False,\r\n 'order': result['order'],\r\n 'error_html': get_processor_decline_html(params)}\r\n except CCProcessorException as error:\r\n return {'success': False,\r\n 'order': None, # due to exception we may not have the order\r\n 'error_html': get_processor_exception_html(error)}","def scrapeFollowingFromAnAccount():\n global api","def send_verification(self):\n pass","def evaluate_cancellation_pending_due_to_non_pay(self, date_cursor=None):\n\n if not date_cursor:\n date_cursor = datetime.now().date()\n\n invoices = Invoice.query.filter_by(policy_id=self.policy.id)\\\n .filter(Invoice.due_date <= date_cursor, date_cursor < Invoice.cancel_date)\\\n .order_by(Invoice.bill_date)\\\n .all()\n\n for invoice in invoices:\n if not self.return_account_balance(invoice.cancel_date):\n continue\n else:\n print \"THIS POLICY STATUS IS PENDING CANCELED\"\n return True\n break\n else:\n print \"THIS POLICY IS NOT PENDING CANCELED\"\n\n return False","def test_payment(self):\n debit_jobs([(self.job, A(480), Entry.WORK_DEBIT)])\n credit_jobs([(self.job, A(480), A(0), A(0))], D(480))\n self.assert_balances(\n bank=A(480, 0, 0),\n invoiced=A(480),\n paid=A(-480),\n partial=A(480).net_amount,\n tax=A(480).tax_amount,\n )","def check_mitm_status_page(self, check_url):\n response = requests.get(check_url)\n if response.status_code == 200:\n return response\n else:\n sys.exit(2)","def _onSuccess(self, controller):\r\n if controller.order.paid_in_full:\r\n controller.cart.empty()\r\n for item in controller.order.orderitem_set.all():\r\n if item.product.is_subscription:\r\n item.completed = True\r\n item.save()\r\n try:\r\n curr_status = controller.order.orderstatus_set.latest() \r\n except OrderStatus.DoesNotExist:\r\n curr_status = None\r\n \r\n if (curr_status is None) or (curr_status.notes and curr_status.status == \"New\"):\r\n controller.order.add_status(status='New', notes = \"Order successfully submitted\")\r\n else:\r\n # otherwise just update and save\r\n if not curr_status.notes:\r\n curr_status.notes = _(\"Order successfully submitted\")\r\n curr_status.save() \r\n\r\n #Redirect to the success page\r\n url = controller.lookup_url('satchmo_checkout-success')\r\n return HttpResponseRedirect(url) \r\n\r\n else:\r\n log.debug('Order #%i not paid in full, sending to pay rest of balance', controller.order.id)\r\n #url = controller.order.get_balance_remaining_url()\r\n url = reverse('satchmo_balance_remaining')\r\n return HttpResponseRedirect(url)","def collect_payment():\n\n # 1. Get required arguments\n args = Eg014Controller.get_args()\n try:\n # 2. Call the worker method\n results = Eg014Controller.worker(args)\n except ApiException as err:\n return process_error(err)\n\n # 3. Render success response\n return render_template(\n \"example_done.html\",\n title=\"Envelope sent\",\n h1=\"Envelope sent\",\n message=f\"\"\"The envelope has been created and sent!<br/> Envelope ID {results[\"envelope_id\"]}.\"\"\"\n )","def update_payment_status(self):\n payments = Payment.query.filter_by(invoice_id=self.id).all()\n total = 0.0\n for payment in payments:\n total += float(payment.amount)\n\n if total >= self.total:\n self.payment_status = u'paid'\n else:\n self.payment_status = u'unpaid'\n\n db.session.add(self)\n db.session.commit()\n\n return False"],"string":"[\n \"def check_payment_status():\\n\\ttry:\\n\\t\\torders = []\\n\\t\\terror_log = {}\\n\\t\\tfields = [\\\"name\\\", \\\"sales_tokens\\\"]\\n\\t\\tfilters = {\\n\\t\\t\\t\\\"payment_status\\\": (\\\"in\\\", [\\\"Pending\\\", \\\"\\\", None]),\\n\\t\\t\\t\\\"docstatus\\\": (\\\"!=\\\", 2),\\n\\t\\t\\t\\\"mode_of_order\\\": \\\"Web\\\"\\n\\t\\t}\\n\\t\\tdue_orders = frappe.get_list(\\\"Sales Order\\\", fields=fields, filters=filters)\\n\\t\\tif len(due_orders):\\n\\t\\t\\turl = \\\"https://testicredit.rivhit.co.il/API/PaymentPageRequest.svc/SaleDetails\\\"\\n\\t\\t\\theaders = {\\\"Content-Type\\\": \\\"application/json\\\", \\\"user-agent\\\": \\\"Playfunction App\\\"}\\n\\t\\t\\tmethod = \\\"POST\\\"\\n\\n\\t\\t\\tfor order in due_orders:\\n\\t\\t\\t\\ttokens = order.get(\\\"sales_tokens\\\")\\n\\t\\t\\t\\tsales_token = json.loads(tokens)[\\\"PrivateSaleToken\\\"]\\n\\t\\t\\t\\tdata = {\\\"SalePrivateToken\\\": sales_token}\\n\\t\\t\\t\\tresponse = request(method, url, data=json.dumps(data), headers=headers)\\n\\t\\t\\t\\t# check payment status\\n\\t\\t\\t\\tif response.status_code == 200:\\n\\t\\t\\t\\t\\tresponse = json.loads(response.text)\\n\\t\\t\\t\\t\\tif not response.get(\\\"status\\\") and response.get(\\\"Amount\\\") \\\\\\n\\t\\t\\t\\t\\t\\tand response.get(\\\"AuthNum\\\"):\\n\\t\\t\\t\\t\\t\\t# TODO: partial payment - response.get(\\\"Amount\\\") != order amt\\n\\t\\t\\t\\t\\t\\tfrappe.db.set_value(\\\"Sales Order\\\", order.get(\\\"name\\\"), \\\"payment_status\\\", \\\"Paid\\\")\\n\\t\\t\\t\\t\\t\\tfrappe.db.commit()\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t# update error log\\n\\t\\t\\t\\t\\terror_log[order.get(\\\"name\\\")] = response.text\\n\\t\\tif error_log.keys():\\n\\t\\t\\tfrappe.error_log(message=json.dumps(error_log), title=\\\"Scheduler Event Failed\\\")\\n\\texcept Exception as e:\\n\\t\\tfrappe.log_error(message=frappe.get_traceback() , title=\\\"Scheduler Event: check_payment_status\\\")\",\n \"def awaiting_payment(self):\",\n \"def paynow_return(request, payment_id):\\r\\n # Get payment object\\r\\n payment = get_object_or_404(PaynowPayment, reference=payment_id)\\r\\n # Init Paynow oject. The urls can now be blank\\r\\n paynow = Paynow(settings.PAYNOW_INTEGRATION_ID, settings.PAYNOW_INTEGRATION_KEY, '', '')\\r\\n\\r\\n # Check the status of the payment with the paynow server\\r\\n payment_result = paynow.check_transaction_status(payment.poll_url)\\r\\n\\r\\n save_changes = False\\r\\n\\r\\n # check if status has changed\\r\\n if payment.status != payment_result.status:\\r\\n payment.status = payment_result.status\\r\\n save_changes = True\\r\\n\\r\\n # Check if paynow reference has changed\\r\\n if payment.paynow_reference != payment_result.paynow_reference:\\r\\n payment.paynow_reference = payment_result.paynow_reference\\r\\n save_changes = True\\r\\n\\r\\n # Check if payment is now paid\\r\\n print(payment_result.paid)\\r\\n if payment_result.paid:\\r\\n if not payment.paid:\\r\\n payment.paid = True\\r\\n payment.confirmed_at = timezone.now()\\r\\n\\r\\n if save_changes:\\r\\n payment.save()\\r\\n\\r\\n msg = \\\"Payment for Transaction \\\" + payment.reference + ' confirmed'\\r\\n msg += \\\" Paynow Reference: \\\" + payment.paynow_reference\\r\\n messages.success(request, msg)\\r\\n msg = \\\"Paynow Payment status => \\\" + payment.status\\r\\n messages.success(request, msg)\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n return redirect(reverse('index'))\",\n \"def payment_check(payload):\\n response = requests.post(url, data=payload)\\n return response.json()\",\n \"def status():\\n if not session.get('user_id'):\\n return redirect(url_for('home.login'))\\n if request.method == 'GET':\\n payment = controllers.get_last_payment(session['user_id'])\\n if not payment:\\n return redirect(url_for('membership.pay'))\\n return render_template('status.html', payment=payment)\",\n \"def payReturn(request, *args, **kwargs):\\n initParam = {}\\n pay_key = request.session.get('pay_key', None)\\n gateway = request.session.get('gateway', None)\\n if pay_key and gateway:\\n del request.session['pay_key']\\n del request.session['gateway']\\n #Check and get Transaction information\\n checkMethod = kwargs.pop('checkMethod', None)\\n if checkMethod:\\n initParam['pay_key'] = pay_key\\n initParam['gateway'] = gateway\\n transaction = checkMethod(request, initParam=initParam)\\n if transaction:\\n p = driver.PayPal()\\n #Check whether use has paid successfully.\\n result = p.check_ap_payment_status(transaction.pay_key)\\n if result['status'][0] == 'COMPLETED':\\n #Do something after user payed successfully.\\n executeMethod = kwargs.pop('executeMethod', None)\\n if executeMethod:\\n initParam['transaction_id'] = transaction.id\\n initParam['buyer_account'] = result['senderEmail'][0]\\n if executeMethod(initParam=initParam):\\n success_page = request.session.get('success_page', None)\\n back_page = request.session.get('back_page', None)\\n if back_page:\\n del request.session['back_page']\\n if success_page:\\n del request.session['success_page']\\n initParam['success_page'] = success_page\\n initParam['success_page_msg'] = request.session['success_page_msg']\\n #For the value in paypal_success.html\\n initParam['app'] = transaction.app\\n initParam['price'] = transaction.price\\n initParam['type'] = 'Transaction'\\n initParam['msg'] = _('You have successfully paid the money. We have already sent an email to the app seller. In the meanwhile you can send private message to seller as well.')\\n log.info(_('User %(param1)s has paid with transaction id %(param2)s.')\\n % {'param1': request.user.username, 'param2': transaction.id})\\n return render_to_response(\\\"payment/paypal_success.html\\\", initParam, context_instance=RequestContext(request))\\n else:\\n log.error(_('User %(param1)s has paid with transaction id %(param2)s, but execute method %(param3)s failed.')\\n % {'param1': request.user.username, 'param2': transaction.id, 'param3': executeMethod.__name__})\\n else:\\n log.error(_('User %(param1)s has paid with transaction id %(param2)s, but ExecuteMethod does not exist.')\\n % {'param1': request.user.username, 'param2': transaction.id})\\n else:\\n log.error(_('User %(param1)s has no paid with transaction id %(param2)s.')\\n % {'param1': request.user.username, 'param2': transaction.id})\\n else:\\n log.error(_('PayKey %(param1)s, Gateway: %(param2)s, User: %(param3)s, Execute method %(param4)s failed.')\\n % {'param1': pay_key, 'param2': gateway, 'param3': request.user.username, 'param4': checkMethod.__name__})\\n else:\\n log.error(_('PayKey %(param1)s, Gateway: %(param2)s, CheckMethod does not exist.')\\n % {'param1': pay_key, 'param2': gateway})\\n else:\\n log.error(_('Pay. PayKey or Gateway no exists.'))\\n\\n success_page = request.session.get('success_page', None)\\n back_page = request.session.get('back_page', None)\\n if success_page:\\n del request.session['success_page']\\n if back_page:\\n del request.session['back_page']\\n error_msg = driver.GENERIC_PAYPAL_ERROR\\n page_msg = request.session['back_page_msg']\\n return render_to_response('payment/paypal_cancel.html',\\n {'error_msg': error_msg, 'back_page': back_page, 'back_page_msg': page_msg}, context_instance=RequestContext(request))\\n else:\\n error_msg = _('%(param1)s Please transaction again.') % {'param1': driver.GENERIC_PAYPAL_ERROR}\\n return render_to_response('payment/paypal_error.html',\\n {\\\"error_msg\\\": error_msg}, context_instance=RequestContext(request))\",\n \"def check_payment(self):\\n return self.payment\",\n \"def payment_verification(payload):\\n response = requests.post(url, data=payload)\\n return response.json()\",\n \"def payPalDoCheckOut(request, *args, **kwargs):\\n initParam = {}\\n id = request.GET.get(\\\"id\\\")\\n token = request.GET.get(\\\"token\\\")\\n payerID = request.GET.get(\\\"PayerID\\\")\\n initParam['id'] = id\\n initParam['token'] = token\\n if token and payerID and id:\\n #Check and get Service detail information\\n checkMethod = kwargs.pop('checkMethod', None)\\n if checkMethod:\\n gateway = request.session.get('gateway', None)\\n if gateway:\\n del request.session['gateway']\\n initParam['gateway'] = gateway\\n serviceDetail = checkMethod(request, initParam=initParam)\\n if serviceDetail:\\n amount = serviceDetail.actual_amount\\n currency = serviceDetail.app.currency.currency\\n result, response = utils.process_payment_request(amount, currency, token, payerID)\\n if result:\\n #Do something after payment success.\\n executeMethod = kwargs.pop('executeMethod', None)\\n if executeMethod:\\n initParam['serviceDetail_id'] = serviceDetail.id\\n if executeMethod(request, initParam=initParam):\\n success_page = request.session.get('success_page', None)\\n back_page = request.session.get('back_page', None)\\n if back_page:\\n del request.session['back_page']\\n if success_page:\\n del request.session['success_page']\\n initParam['success_page'] = success_page\\n initParam['success_page_msg'] = request.session['success_page_msg']\\n #For the value in paypal_success.html\\n initParam['app'] = serviceDetail.app\\n initParam['type'] = 'Payment'\\n initParam['price'] = serviceDetail.actual_amount\\n initParam['msg'] = _('Thank you for your payment, and your app will be listed according to the effective period your choosed.')\\n log.info(_('Seller %(param1)s has paid service fee with service detail id %(param2)s.')\\n % {'param1': request.user.username, 'param2': serviceDetail.id})\\n return render_to_response(\\\"payment/paypal_success.html\\\", initParam, context_instance=RequestContext(request))\\n else:\\n log.error(_('Token %(param1)s, PayerID: %(param2)s, Execute method %(param3)s failed.')\\n % {'param1': token, 'param2': payerID, 'param3': executeMethod.__name__})\\n else:\\n log.error(_('Token %(param1)s, PayerID: %(param2)s, ExecuteMethod does not exist.')\\n % {'param1': token, 'param2': payerID})\\n else:\\n log.error(_('Token %(param1)s, PayerID: %(param2)s, %(param3)s : %(param4)s.')\\n % {'param1': token, 'param2': payerID, 'param3': response.error, 'param4': response.error_msg})\\n else:\\n log.error(_('Token %(param1)s, PayerID: %(param2)s, User: %(param3)s, Execute method %(param4)s failed.')\\n % {'param1': token, 'param2': payerID, 'param3': request.user.username, 'param4': checkMethod.__name__})\\n else:\\n log.error(_('Token %(param1)s, PayerID: %(param2)s, Gateway no exists in request.session.')\\n % {'param1': token, 'param2': payerID})\\n else:\\n log.error(_('Token %(param1)s, PayerID: %(param2)s, CheckMethod does not exist.')\\n % {'param1': token, 'param2': payerID})\\n else:\\n log.error(_('Token or PayerID no exists.'))\\n\\n if request.session.get('gateway', None):\\n del request.session['gateway']\\n success_page = request.session.get('success_page', None)\\n back_page = request.session.get('back_page', None)\\n if success_page:\\n del request.session['success_page']\\n if back_page:\\n del request.session['back_page']\\n error_msg = driver.GENERIC_PAYPAL_ERROR\\n page_msg = request.session['back_page_msg']\\n return render_to_response('payment/paypal_cancel.html',\\n {'error_msg': error_msg, 'back_page': back_page, 'back_page_msg': page_msg}, context_instance=RequestContext(request))\\n else:\\n error_msg = _('%(param1)s Please payment again.') % {'param1': driver.GENERIC_PAYPAL_ERROR}\\n return render_to_response('payment/paypal_error.html',\\n {\\\"error_msg\\\": error_msg}, context_instance=RequestContext(request))\",\n \"def run_now(request):\\n rp_id = request.POST.get('rp_id')\\n rp = get_object_or_404(RecurringPayment, pk=rp_id)\\n\\n result_data = {}\\n result_data['processed'] = 'false'\\n result_data['reason'] = 'done'\\n\\n payment_profiles = PaymentProfile.objects.filter(\\n customer_profile_id=rp.customer_profile_id,\\n status=True,\\n status_detail='active'\\n ).order_by('-update_dt')\\n if not payment_profiles:\\n valid_cpp_ids, invalid_cpp_ids = rp.populate_payment_profile()\\n #print valid_cpp_ids, invalid_cpp_ids\\n\\n if valid_cpp_ids:\\n payment_profiles = PaymentProfile.objects.filter(\\n customer_profile_id=valid_cpp_ids[0])\\n\\n if not payment_profiles:\\n result_data['reason'] = 'not setup'\\n else:\\n if rp.status_detail == 'active':\\n num_processed = run_a_recurring_payment(rp)\\n if num_processed:\\n result_data['processed'] = 'true'\\n result_data['reason'] = 'processed'\\n # get total_paid and balance for this rp\\n result_data['total_paid'] = str(rp.total_paid)\\n result_data['balance'] = str(rp.get_outstanding_balance())\\n\\n # get total amount received for all rps\\n d = RecurringPaymentInvoice.objects.filter(\\n invoice__balance=0,\\n ).aggregate(total_amount_received=Sum('invoice__total'))\\n result_data['total_amount_received'] = d['total_amount_received']\\n if not result_data['total_amount_received']:\\n result_data['total_amount_received'] = 0\\n result_data['total_amount_received'] = tcurrency(result_data['total_amount_received'])\\n\\n return HttpResponse(simplejson.dumps(result_data))\",\n \"def verifysubscriptionstatusinaccounttab():\\n pass\",\n \"def proceed_to_checkout_and_payment(self):\\r\\n # 1- summary\\r\\n logger.info('starting wizard with summary')\\r\\n self.automation.wait.until(\\r\\n EC.presence_of_element_located((By.CSS_SELECTOR, '.cart_navigation a.standard-checkout')))\\r\\n self.automation.driver.execute_script(\\\"document.querySelectorAll('.cart_navigation a.standard-checkout')[0]\\\"\\r\\n \\\".click()\\\")\\r\\n\\r\\n # 2-sign in & 3-address\\r\\n logger.info('2-sign in & 3-address')\\r\\n self.automation.wait.until(\\r\\n EC.presence_of_element_located((By.CSS_SELECTOR, 'button[name=\\\"processAddress\\\"]')))\\r\\n\\r\\n self.automation.driver.find_element_by_css_selector('button[name=\\\"processAddress\\\"]').click()\\r\\n\\r\\n # 4- shipping\\r\\n logger.info('4- shipping')\\r\\n self.automation.wait.until(\\r\\n EC.presence_of_element_located((By.CSS_SELECTOR, '#uniform-cgv span')))\\r\\n\\r\\n is_checked = self.automation.driver.find_element_by_css_selector('#uniform-cgv span').get_attribute('class')\\r\\n if not is_checked: # agree\\r\\n self.automation.driver.execute_script(\\\"document.querySelectorAll('#cgv')[0].click()\\\")\\r\\n\\r\\n self.automation.driver.find_element_by_css_selector('button[name=processCarrier]').click()\\r\\n logger.info('agree and confirmed')\\r\\n\\r\\n # pay by bank wire\\r\\n logger.info('pay by bank wire')\\r\\n self.automation.wait.until(\\r\\n EC.presence_of_element_located((By.CSS_SELECTOR, '.payment_module a')))\\r\\n\\r\\n self.automation.driver.find_element_by_css_selector('.payment_module a').click()\\r\\n\\r\\n # 5- payment and confirm\\r\\n logger.info('5- payment and confirm')\\r\\n self.automation.wait.until(\\r\\n EC.presence_of_element_located((By.CSS_SELECTOR, '#cart_navigation button')))\\r\\n self.automation.driver.find_element_by_css_selector('#cart_navigation button').click()\\r\\n\\r\\n # back to orders\\r\\n logger.info('back to orders')\\r\\n self.automation.wait.until(\\r\\n EC.presence_of_element_located((By.CSS_SELECTOR, 'p.cart_navigation .button-exclusive.btn')))\\r\\n self.automation.driver.find_element_by_css_selector('p.cart_navigation .button-exclusive.btn').click()\\r\\n\\r\\n # how many items do you have\\r\\n time.sleep(1.5)\\r\\n self.automation.wait.until(\\r\\n EC.presence_of_element_located((By.CSS_SELECTOR, '#order-list tbody tr')))\\r\\n items = self.automation.driver.find_elements_by_css_selector('#order-list tbody tr')\\r\\n logger.info(f'You have \\\"{len(items)}\\\" at your order')\",\n \"def check() -> bool:\\n today = datetime.now(timezone(timedelta(hours=2)))\\n second_period = today + timedelta(days=7)\\n third_period = second_period + timedelta(days=7)\\n periods = list(\\n map(\\n lambda item: item.strftime(\\\"%Y-%m-%d\\\"), [today, second_period, third_period]\\n )\\n )\\n\\n periods_urls = map(\\n lambda item: f\\\"https://ezakupy.tesco.pl/groceries/pl-PL/slots/delivery/{item}?slotGroup=2\\\",\\n periods,\\n )\\n url_login = \\\"https://ezakupy.tesco.pl/groceries/pl-PL/login\\\"\\n\\n session = requests.Session()\\n\\n response_login_form = session.get(url_login)\\n soup = BeautifulSoup(response_login_form.content, features=\\\"html.parser\\\")\\n csrf_token = soup.find(attrs={\\\"name\\\": \\\"_csrf\\\"}).attrs[\\\"value\\\"]\\n\\n session.post(\\n url_login,\\n data={\\n \\\"onSuccessUrl\\\": \\\"\\\",\\n \\\"email\\\": os.environ.get(\\\"TESCO_EMAIL\\\", \\\"\\\"),\\n \\\"password\\\": os.environ.get(\\\"TESCO_PASSWORD\\\", \\\"\\\"),\\n \\\"_csrf\\\": csrf_token,\\n },\\n headers={\\\"Content-Type\\\": \\\"application/x-www-form-urlencoded\\\"},\\n )\\n\\n period_results = map(lambda url: get_slots_for_date(url, session), periods_urls)\\n list_of_slots = []\\n\\n for period_result in period_results:\\n for slot in period_result:\\n list_of_slots.append(slot)\\n\\n if len(list_of_slots) > 0:\\n send_email(\\n email_address(), \\\"Free slot available\\\", f\\\"Free slots {len(list_of_slots)}\\\"\\n )\\n print(\\\"Free slot available. \\\", len(list_of_slots))\\n return True\\n else:\\n print(\\\"No available slots\\\")\\n return False\",\n \"def run(self):\\n self.getPrice()\\n #time.sleep(5)\\n self.compare_price()\\n #time.sleep(5)\\n if self.__alert_client is True:\\n self.send_email()\\n #self.display()\\n return True\\n else:\\n #self.display()\\n return False\",\n \"def slot_poll(self, _sender, _data):\\r\\n if self.client.secret and self.client.secret.know_secret():\\r\\n # poll recent own trades\\r\\n # fixme: how do i do this, whats the api for this?\\r\\n pass\",\n \"def payment(self, **post):\\n cr, uid, context = request.cr, request.uid, request.context\\n payment_obj = request.registry.get('payment.acquirer')\\n sale_order_obj = request.registry.get('sale.order')\\n\\n order = request.website.sale_get_order(context=context)\\n order.write({'usersess': request.session['webcalc_session_id']})\\n #order.env.cr.commit()\\n redirection = self.checkout_redirection(order)\\n if redirection:\\n return redirection\\n\\n shipping_partner_id = False\\n if order:\\n if order.partner_shipping_id.id:\\n shipping_partner_id = order.partner_shipping_id.id\\n else:\\n shipping_partner_id = order.partner_invoice_id.id\\n\\n values = {\\n 'order': request.registry['sale.order'].browse(cr, SUPERUSER_ID, order.id, context=context),\\n 'usersess': request.session['webcalc_session_id']\\n }\\n values['errors'] = sale_order_obj._get_errors(cr, uid, order, context=context)\\n values.update(sale_order_obj._get_website_data(cr, uid, order, context))\\n\\n if not values['errors']:\\n acquirer_ids = payment_obj.search(cr, SUPERUSER_ID, [('website_published', '=', True), ('company_id', '=', order.company_id.id)], context=context)\\n values['acquirers'] = list(payment_obj.browse(cr, uid, acquirer_ids, context=context))\\n render_ctx = dict(context, submit_class='btn btn-primary', submit_txt=_('Завершить оформление'))\\n for acquirer in values['acquirers']:\\n acquirer.button = payment_obj.render(\\n cr, SUPERUSER_ID, acquirer.id,\\n '/',\\n order.amount_total,\\n order.pricelist_id.currency_id.id,\\n partner_id=shipping_partner_id,\\n tx_values={\\n 'return_url': '/shop/payment/validate',\\n },\\n context=render_ctx)\\n #vips_shop\\n return request.website.render(\\\"vips_shop.payment\\\", values)\",\n \"def checkPayComplete(*args, **kwargs):\\n initParam = {}\\n transaction = kwargs.get('transaction')\\n if transaction:\\n p = driver.PayPal()\\n #Check whether use has paid successfully.\\n result = p.check_ap_payment_status(transaction.pay_key)\\n if result['status'][0] != 'COMPLETED':\\n #Do something after user payed successfully.\\n executeMethod = kwargs.pop('executeMethod', None)\\n if executeMethod:\\n initParam['transaction_id'] = transaction.id\\n initParam['pay_key'] = transaction.pay_key\\n initParam['buyer_account'] = result['senderEmail'][0]\\n executeMethod(initParam=initParam)\",\n \"def getStatus(entry, vType):\\n data = db.Database(filename=\\\"IFB299.db\\\")\\n fine = data.retrieveFine(vType, entry['Citation_Number'])\\n if fine['Payment_status'] == \\\"Pending\\\":\\n date = dt.datetime.strptime(entry['Date'],'%d/%m/%Y')\\n overdue = dt.datetime.now().date() - date.date()\\n if overdue.days >= 7:\\n return \\\"Overdue\\\"\\n else:\\n return \\\"Pending\\\"\\n else:\\n return \\\"Paid\\\"\",\n \"def isw_callback(md=None, pa_res=None):\\n url = cardinal_endpoint + '/collections/api/v1/pay/cardinalCallBack'\\n\\n headers = {'Accept':'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',\\n 'Accept-Encoding':'gzip, deflate, br',\\n 'Accept-Language':'fr-FR,fr;q=0.9,en-GB;q=0.8,en;q=0.7,fr-CA;q=0.6,en-US;q=0.5',\\n 'Content-Length':'4170',\\n 'Content-Type':'application/x-www-form-urlencoded',\\n 'User-Agent':'Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.146 Safari/537.36'}\\n\\n data = {'MD': md,'PaRes':pa_res}\\n\\n make_request = requests.post(url, data=data, headers=headers)\\n visa_purchase = make_request.status_code\\n print(visa_purchase)\\n if visa_purchase == 200:\\n return True\\n else:\\n return False\",\n \"def check_status(self):\",\n \"def test_buy_now(self):\\n catalog_page = CatalogPage(self.driver)\\n product_page = ProductPage(self.driver)\\n payment_page = PaymentPage(self.driver)\\n payment_review_page = PaymentReviewPage(self.driver)\\n payment_info_page = PaymentInfoPage(self.driver)\\n success_page = SuccessPage(self.driver)\\n # buy the new product\\n navigate_to(self.driver, ProductPage.URL(self.new_product['product']['title']))\\n product_page.add_to_cart.click()\\n # by an old product\\n catalog_page.catalog.click()\\n # Sort products to move the newly created to last page\\n catalog_page.sorting_order.select_by_visible_text(\\\"Date, old to new\\\")\\n catalog_page.image.random_click()\\n product = product_page.product.get_text()\\n product_page.add_to_cart.click()\\n catalog_page.catalog.click()\\n catalog_page.cart.click()\\n payment_dic = {\\n 'address' : f'{randint(1, 99999)} {random_name(5, 8)}',\\n 'city' : \\\"San Francisco\\\",\\n 'email_or_mobile_phone_number_input' : random_name(8) + \\\"@gmail.com\\\",\\n 'last_name' : random_name(3, 12),\\n 'zip_code' : '94107',\\n }\\n if randint(0, 1):\\n payment_dic['first_name'] = random_name(4, 16)\\n if randint(0, 1):\\n payment_dic['address2'] = random_name(5)\\n for _ in payment_dic:\\n exec(f\\\"payment_page.{_}.enter(payment_dic['{_}'])\\\")\\n payment_page.continue_to_shipping.click()\\n payment_review_page.continue_to_payment.click()\\n payment_info_page.full_address.get_text()\\n # validate address\\n for _ in ['address', 'city', 'zip_code']:\\n assert_and_log(payment_dic[_] in payment_info_page.full_address.get_text(),\\n f\\\"{_} in full address\\\")\\n payment_info_page.enter_bogus_payment(1)\\n assert_and_log(success_page.thank_you.find_visible_element(),\\n \\\"'Thank you' appeared as a sign of successful transaction\\\",\\n continue_on_error=False)\\n validate(success_page.basic_validation_list)\",\n \"def test_authorize_pending_payment(self):\\n pass\",\n \"def is_payout_available(self):\\r\\n return False # Disabled because artist receives payout directly from fan\\r\\n # return self.has_ended and not self.is_payout_requested and self.amount_raised_online and not self.is_deleted\\r\",\n \"def pay_in_full():\\n _validate_fields(PAYMENT_FIELDS)\\n dbhandlers.handle_pay_in_full(request.form)\\n return dumps({\\\"response\\\": \\\"success\\\"})\",\n \"def process_payment():\\n\\n url = 'https://api.worldpay.com/v1/orders'\\n headers = {'Authorization': environ.get('WORLDPAY_API_KEY'),\\n 'Content-type': 'application/json'}\\n body = {\\n \\\"paymentMethod\\\": {\\n \\\"type\\\": \\\"Card\\\",\\n \\\"name\\\": session['caller_name'],\\n \\\"expiryMonth\\\": session['expiry'][:2],\\n \\\"expiryYear\\\": f\\\"20{session['expiry'][2:]}\\\",\\n \\\"cardNumber\\\": session['card_number'],\\n \\\"cvc\\\": session['cvv'],\\n \\\"issueNumber\\\": \\\"1\\\"\\n },\\n \\\"orderType\\\": \\\"ECOM\\\",\\n \\\"orderDescription\\\": session['call_sid'],\\n \\\"amount\\\": session['payment_amount'],\\n \\\"currencyCode\\\": \\\"GBP\\\"}\\n r = requests.post(url, headers=headers, data=json.dumps(body))\\n requests.post(environ.get('END_OF_INTERACTION_URL'), r.text)\\n response = VoiceResponse()\\n response.say(\\\"Payment processed, goodbye\\\")\\n # If your flow started in Twilio Studio, redirect back to it to complete the call\\n # response.redirect(\\n # 'https://webhooks.twilio.com/v1/Accounts/ACfd0573f9f976b99746c693XXXXXXXXXX/Flows/FWbfdeda0a21644267231d3dXXXXXXXXXX?FlowEvent=return')\\n return str(response)\",\n \"def test_deny_pending_payment(self):\\n pass\",\n \"def no_payment_required(self):\",\n \"def payPalReturn(request, *args, **kwargs):\\n initParam = {}\\n token = request.GET.get('token')\\n payerID = request.GET.get('PayerID')\\n initParam['token'] = token\\n initParam['payerid'] = payerID\\n if token and payerID:\\n p = driver.PayPal()\\n EC_RETURNURL = '/'.join([common.getHttpHeader(request), 'payment/paypal_return'])\\n EC_CANCELURL = '/'.join([common.getHttpHeader(request), 'payment/paypal_cancel'])\\n res_dict = p.GetExpressCheckoutDetailsInfo(EC_RETURNURL, EC_CANCELURL, token)\\n state = p._get_value_from_qs(res_dict, 'ACK')\\n if state in [\\\"Success\\\", \\\"SuccessWithWarning\\\"]:\\n #Show the list of service detail to user.\\n executeMethod = kwargs.pop('executeMethod', None)\\n if executeMethod:\\n gateway = request.session.get('gateway', None)\\n if gateway:\\n initParam['gateway'] = gateway\\n serviceDetail, serviceItems, discount_rate = executeMethod(request, initParam=initParam)\\n if serviceDetail and serviceItems:\\n initParam['serviceDetail'] = serviceDetail\\n initParam['serviceItems'] = serviceItems\\n initParam['discount_rate'] = discount_rate\\n return render_to_response('payment/paypal_return.html', initParam, context_instance=RequestContext(request))\\n else:\\n log.error(_('Token %(param1)s, PayerID: %(param2)s, Execute method %(param3)s failed.')\\n % {'param1': token, 'param2': payerID, 'param3': executeMethod.__name__})\\n else:\\n log.error(_('Token %(param1)s, PayerID: %(param2)s. Gateway no exists in request.session.')\\n % {'param1': token, 'param2': payerID})\\n else:\\n log.error(_('Token %(param1)s, PayerID: %(param2)s, ExecuteMethod does not exist.')\\n % {'param1': token, 'param2': payerID})\\n else:\\n error = p._get_value_from_qs(res_dict, 'L_SHORTMESSAGE0')\\n log.error(_('Token %(param1)s, PayerID: %(param2)s, %(param3)s.')\\n % {'param1': token, 'param2': payerID, 'param3': error})\\n else:\\n log.error(_('Token or PayerID no exists.'))\\n\\n if request.session.get('gateway', None):\\n del request.session['gateway']\\n success_page = request.session.get('success_page', None)\\n back_page = request.session.get('back_page', None)\\n if success_page:\\n del request.session['success_page']\\n if back_page:\\n del request.session['back_page']\\n error_msg = driver.GENERIC_PAYPAL_ERROR\\n page_msg = request.session['back_page_msg']\\n return render_to_response('payment/paypal_cancel.html',\\n {'error_msg': error_msg, 'back_page': back_page, 'back_page_msg': page_msg}, context_instance=RequestContext(request))\\n else:\\n error_msg = _('%(param1)s Please payment again.') % {'param1': driver.GENERIC_PAYPAL_ERROR}\\n return render_to_response('payment/paypal_error.html',\\n {\\\"error_msg\\\": error_msg}, context_instance=RequestContext(request))\",\n \"def credit_deliverer():\\n return True\",\n \"def check_award_status(request, award, now):\\n auction = request.validated['auction']\\n protocol_overdue = protocol_overdue_predicate(award, 'pending.verification', now)\\n contract_overdue = contract_overdue_predicate(award, 'active', now)\\n payment_overdue = (award.status == 'pending.payment' and award['paymentPeriod']['endDate'] < now)\\n if protocol_overdue or contract_overdue or payment_overdue:\\n set_unsuccessful_award(request, auction, award, now)\",\n \"def get_status() -> None:\\n assert scraper.get_status() == True\",\n \"def test_get_pay_in_details(self):\\n pass\",\n \"def test_retrieve_iso20022_payment_instruction_status_report(self):\\n pass\",\n \"def paid(self):\\n return self.get('paid')\",\n \"def webhook_payment_successful(self, event):\\n\\n intent = event.data.object\\n p_id = intent.id\\n pack = intent.metadata.pack\\n save_detail = intent.metadata.save_detail\\n\\n billing_details = intent.charges.data[0].billing_details\\n shipping_details = intent.shipping\\n grand_cost = round(intent.charges.data[0].amount / 100, 2)\\n\\n for field, value in shipping_details.address.items():\\n if value == \\\"\\\":\\n shipping_details.address[field] = None\\n\\n profile = None\\n username = intent.metadata.username\\n if username != 'AnonymousUser':\\n profile = UserProfile.objects.get(user__username=username)\\n if save_detail:\\n profile.default_phone_number = shipping_details.phone,\\n profile.default_home_Address = shipping_details.address.line1,\\n profile.default_home_Address_continued = \\\\\\n shipping_details.address.line2,\\n profile.default_postcode = \\\\\\n shipping_details.address.postal_code,\\n profile.default_county = \\\\\\n shipping_details.address.city,\\n profile.default_country = \\\\\\n shipping_details.address.country,\\n profile.save()\\n\\n order_present = False\\n seek = 1\\n while seek <= 6:\\n try:\\n order = Order.objects.get(\\n Name__iexact=shipping_details.name,\\n user_account=profile,\\n email__iexact=billing_details.email,\\n phone_number__iexact=shipping_details.phone,\\n home_Address__iexact=shipping_details.address.line1,\\n home_Address_continued__iexact =(\\n shipping_details.address.line2\\n ),\\n postcode__iexact=shipping_details.address.postal_code,\\n county__iexact=shipping_details.address.city,\\n country__iexact=shipping_details.address.country,\\n grand_cost=grand_cost,\\n original_pack=pack,\\n stripe_p_id=p_id,\\n )\\n order_present = True\\n break\\n except Order.DoesNotExist:\\n seek += 1\\n time.sleep(1)\\n if order_present:\\n self._send_email_details(order)\\n return HttpResponse(\\n content=f'Webhook obtained: {event[\\\"type\\\"]} | Good news. \\\\\\n This is now in the database',\\n status=200)\\n else:\\n order = None\\n try:\\n order = Order.objects.create(\\n Name=shipping_details.name,\\n email=billing_details.email,\\n phone_number=shipping_details.phone,\\n home_Address=shipping_details.address.line1,\\n home_Address_continued=shipping_details.address.line2,\\n postcode=shipping_details.address.postal_code,\\n county=shipping_details.address.city,\\n country=shipping_details.address.country,\\n original_pack=pack,\\n stripe_p_id=p_id,\\n )\\n for item_id, item_data in json.load(pack).items():\\n product = Product.objects.get(id=item_id)\\n if isinstance(item_data, int):\\n order_line_item = OrderLineItem(\\n order=order,\\n product=product,\\n quantity=item_data,\\n )\\n order_line_item.save()\\n else:\\n for size, quantity in item_data['items_by_size'].items():\\n order_line_item = OrderLineItem(\\n order=order,\\n product=product,\\n quantity=quantity,\\n product_size=size,\\n )\\n order_line_item.save()\\n except Exception as e:\\n if order:\\n order.delete()\\n return HttpResponse(\\n content=f'Webhook obtained: {event[\\\"type\\\"]} | \\\\\\n There is an error: {e}',\\n status=500)\\n self._send_email_details(order)\\n return HttpResponse(\\n content=f'Webhook obtained: {event[\\\"type\\\"]} | \\\\\\n Goodnews: webhook order created',\\n status=200)\",\n \"def validate_with_paypal(request, validate_type):\\n if validate_type == 'PDT':\\n # we are on return url\\n # need to verify if payment is completed\\n # MERCHANT_TXN_KEY is your PDT identity token\\n params = {\\n 'cmd': '_notify-synch',\\n 'tx': request.GET.get('tx', ''),\\n 'at': settings.MERCHANT_TXN_KEY\\n }\\n data = urllib.urlencode(params)\\n\\n # Sample response:\\n # SUCCESS\\n # first_name=Jane+Doe\\n # last_name=Smith\\n # payment_status=Completed payer_email=janedoesmith%40hotmail.com\\n # payment_gross=3.99\\n # mc_currency=USD custom=For+the+purchase+of+the+rare+book+Green+Eggs+%26+Ham\\n\\n # If the response is FAIL, PayPal recommends making sure that:\\n # The Transaction token is not bad.\\n # The ID token is not bad.\\n # The tokens have not expired.\\n\\n else: # IPN\\n data = 'cmd=_notify-validate&%s' % request.POST.urlencode()\\n\\n # The response is one single-word: VERIFIED or INVALID\\n\\n headers = {\\\"Content-type\\\": \\\"application/x-www-form-urlencoded\\\",\\n 'encoding': 'utf-8',\\n \\\"Accept\\\": \\\"text/plain\\\"}\\n request = urllib2.Request(settings.PAYPAL_POST_URL,\\n data,\\n headers)\\n response = urllib2.urlopen(request)\\n data = response.read()\\n\\n if validate_type == 'PDT':\\n return parse_pdt_validation(data)\\n else:\\n return data.strip('\\\\n').lower() == 'verified', None\",\n \"def event_payu_com_dpn(self, **post):\\n cr, uid, context = request.cr, request.uid, request.context\\n payment_acquire = request.env['payment.acquirer'].sudo().search([('provider', '=', 'payu')])\\n transactionDetails = {}\\n transactionDetails['store'] = {}\\n transactionDetails['store']['soapUsername'] = payment_acquire.payu_api_username\\n transactionDetails['store']['soapPassword'] = payment_acquire.payu_api_password\\n transactionDetails['store']['safekey'] = payment_acquire.payu_seller_account\\n transactionDetails['store']['environment'] = payment_acquire.environment\\n transactionDetails['additionalInformation'] = {}\\n transactionDetails['additionalInformation']['payUReference'] = post['PayUReference']\\n try:\\n result = PayuController.payuMeaGetTransactionApiCall('', transactionDetails)\\n payment_transation_id = request.env['payment.transaction'].sudo().search(\\n [('reference', '=', result['merchantReference'])])\\n payu_response = {}\\n if result:\\n payu_response['TRANSACTION_STATUS'] = result['transactionState']\\n # payu_response['SUCCESSFUL'] = result['successful']\\n payu_response['AMOUNT'] = payment_transation_id.amount * 100 if payment_transation_id else 0.00\\n payu_response['CURRENCYCODE'] = result['basket']['currencyCode']\\n payu_response['PAYUREFERENCE'] = result['payUReference']\\n payu_response['REFERENCE'] = result['merchantReference']\\n payu_response['RESULTMESSAGE'] = result['resultMessage']\\n response_state = request.env['payment.transaction'].sudo().form_feedback(payu_response, 'payu')\\n # response_state = PaymentTransactionCus.form_feedback('', payu_response, 'payu')\\n # if response_state:\\n # return werkzeug.utils.redirect('/shop/payment/validate')\\n # else:\\n # return werkzeug.utils.redirect('/shop/unsuccessful')\\n\\n sale_order_id = request.env['sale.order'].sudo().search([('name', '=', result['merchantReference'])])\\n sale_order_data = sale_order_id\\n request.session['sale_last_order_id'] = sale_order_id.id\\n\\n tx_id = request.env['payment.transaction'].sudo().search([('reference', '=', result['merchantReference'])])\\n tx = tx_id\\n if not sale_order_id or (sale_order_id.amount_total and not tx):\\n return request.redirect('/shop')\\n if (not sale_order_id.amount_total and not tx) or tx.state in ['pending']:\\n if sale_order_id.state in ['draft', 'sent']:\\n if (not sale_order_id.amount_total and not tx):\\n sale_order_id.action_button_confirm()\\n email_act = sale_order_id.action_quotation_send()\\n elif tx and tx.state == 'cancel':\\n sale_order_id.action_cancel()\\n elif tx and (tx.state == 'draft' or tx.state == 'sent' or tx.state == 'done'):\\n # if result and payu_response['successful'] and payu_response['TRANSACTION_STATUS'] in ['SUCCESSFUL', 'PARTIAL_PAYMENT', 'OVER_PAYMENT']:\\n if result and payu_response['TRANSACTION_STATUS'] in ['SUCCESSFUL', 'PARTIAL_PAYMENT', 'OVER_PAYMENT']:\\n transaction = tx.sudo().write(\\n {'state': 'done', 'date_validate': datetime.now(),\\n 'acquirer_reference': result['payUReference']})\\n email_act = sale_order_id.action_quotation_send()\\n action_confirm_res = sale_order_id.action_confirm()\\n sale_order = sale_order_id.read([])\\n # if sale_order_id.state == 'sale':\\n # journal_ids = request.env['account.journal'].sudo().search([('name', '=', 'FNB 62085815143')], limit=1)\\n # journal = journal_ids.read([])\\n currency = request.env['res.currency'].sudo().search([('name', '=', 'ZAR')], limit=1)\\n method = request.env['account.payment.method'].sudo().search([('name', '=', 'Manual')], limit=1)\\n journal_id = request.env['account.journal'].sudo().search(\\n [('name', '=', 'FNB - Cheque Account 6208585815143')], limit=1, order=\\\"id desc\\\")\\n if journal_id:\\n account_payment = {\\n 'partner_id': sale_order[0]['partner_id'][0],\\n 'partner_type': 'customer',\\n 'journal_id': journal_id.id,\\n # 'invoice_ids':[(4,inv_obj.id,0)],\\n 'amount': sale_order[0]['amount_total'],\\n 'communication': sale_order_id.name,\\n 'currency_id': currency.id,\\n 'payment_type': 'inbound',\\n 'payment_method_id': method.id,\\n 'payment_transaction_id': tx.id,\\n }\\n acc_payment = request.env['account.payment'].sudo().create(account_payment)\\n acc_payment.sudo().post()\\n sale_order_id = request.session.get('sale_last_order_id')\\n print(\\\"\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n=======================sale order sale order======\\\", sale_order_id)\\n sale_order_data = request.env['sale.order'].sudo().browse(sale_order_id)\\n # if sale_order_data.project_project_id:\\n # request.session['last_project_id'] = sale_order_data.project_project_id.id\\n if response_state:\\n sale_order_data.message_post(subject=\\\"T&C's Privacy Policy\\\",\\n body=\\\"%s accepted T&C's and Privacy Policy.\\\" % sale_order_data.partner_id.name)\\n return werkzeug.utils.redirect('/pay/thankyou')\\n # return werkzeug.utils.redirect('/shop/confirmation')\\n else:\\n return werkzeug.utils.redirect('/event/unsuccessful')\\n except Exception as e:\\n return werkzeug.utils.redirect('/event/unsuccessful')\",\n \"def do(self):\\n self.message += 'Searching for unpayed loans \\\\n'\\n today = dt.now()\\n tomorrow = today + timedelta(days=1)\\n\\n expired = Loan.objects.filter(due_date=today)\\n almost = Loan.objects.filter(due_date=tomorrow)\\n\\n self.charge(expired)\\n self.notify(almost)\\n\\n self.log_success()\",\n \"def hit_send_payment_button(self):\\n\\t\\telement = Element(driver=self.driver,\\n\\t\\t explicit_wait_time=self.explicit_wait_time,\\n\\t\\t locator=BillPayPageLocator.SEND_PAYMENT_BUTTON)\\n\\t\\telement.click_on()\\n\\t\\treturn None\",\n \"def getPayment(self):\\n pass\",\n \"def post(self):\\n policies = json.loads(self.request.get('policies'))\\n request = json.loads(self.request.get('request_json'))\\n response = json.loads(self.request.get('response_json'))\\n\\n maybe_notify_backend('LEASED', response['hostname'], policies)\\n maybe_notify_lessee(request, response)\",\n \"def __check(self):\\n status = '200 OK'\\n try:\\n response = get(self.__url)\\n status = '{} {}'.format(\\n response.status_code,\\n http.client.responses[response.status_code]\\n )\\n except Exception as e:\\n status = e.__class__.__name__\\n \\n if status[:3] == '200':\\n self.__notify_up()\\n else:\\n if not self.downtime_info:\\n self.downtime_info = DowntimeInfo(status)\\n self.__notify_down()\",\n \"def payments(self):\\n # get the summary data\\n options = { 'PayLoadText' : self.payments_request_xml() }\\n\\n response = request.get(self.url, params=options) \\\\\\n .text\\n print(response)\",\n \"def custom_assess_status_check(self):\\n options = self.options\\n # can check options.thing to ensure that it makes sense\\n # if wrong return 'blocked', \\\"The driver is badly configured ...\\\"\\n return None, None\",\n \"def check_account_status(request):\\n\\n user = request.user\\n\\n if not user.is_authenticated():\\n return {\\n 'current_user': user,\\n 'check_account_status_url': reverse('check_account_status'),\\n }\\n\\n session = request.session\\n\\n flag = session.get('show_email_confirmation_dialog', True)\\n show = not user.has_activated_account and flag\\n session['show_email_confirmation_dialog'] = False\\n\\n # We don't want so show email confirmation when use is trying to buy a ticket.\\n if 'payment-details' in request.path:\\n show = False\\n\\n return {\\n 'current_user': user,\\n 'show_email_confirmation_dialog': False,\\n 'check_account_status_url': reverse('check_account_status'),\\n }\",\n \"def m_apiInstance_ConnectionStatusUpdate(self, sender, e):\\r\\n if e.Status.IsSuccess:\\r\\n # Add code here to begin working with the TT API\\r\\n # lookup an instrument\\r\\n self.m_req = ttapi.InstrumentLookupSubscription(self.m_apiInstance.Session, ttapi.Dispatcher.Current, ttapi.ProductKey(ttapi.MarketKey.Cme, ttapi.ProductType.Future, \\\"6J\\\"), \\\"Dec17\\\")\\r\\n self.m_req.Update += self.m_req_Update\\r\\n print(\\\"Connection Success!\\\")\\r\\n self.m_req.Start()\\r\\n else:\\r\\n print(\\\"TT Login failed: {0}\\\".format(e.Status.StatusMessage))\\r\\n self.Dispose()\",\n \"def policy_checker(name):\\n\\n policy = PolicyModel.query(PolicyModel.Name == name).get()\\n if not policy:\\n logging.error(\\\"Policy %s not found!\\\", name)\\n return \\\"not found\\\", 404\\n schedule = SchedulesModel.query(SchedulesModel.Name == policy.Schedule).get()\\n if not schedule:\\n logging.error(\\\"Schedule %s not found!\\\", policy.Schedule)\\n return \\\"not found\\\", 404\\n logging.debug(\\n \\\"Time at Timezone %s is %s\\\",\\n schedule.Timezone,\\n tz.get_time_at_timezone(schedule.Timezone),\\n )\\n day, hour = tz.convert_time_to_index(tz.get_time_at_timezone(schedule.Timezone))\\n logging.debug(\\\"Working on day %s hour %s\\\", day, hour)\\n arr = np.asarray(schedule.Schedule[\\\"__ndarray__\\\"], dtype=np.int).flatten()\\n matrix_size = schedule.Schedule[\\\"Shape\\\"][0] * schedule.Schedule[\\\"Shape\\\"][1]\\n prev = utils.get_prev_idx(day * 24 + hour, matrix_size)\\n now = arr[day * 24 + hour]\\n prev = arr[prev]\\n logging.info(\\\"Previous state %s current %s\\\", prev, now)\\n if now == prev:\\n # do nothing\\n logging.info(\\\"Conditions are met, Nothing should be done for %s\\\", name)\\n return \\\"ok\\\", 200\\n else:\\n # stop/start\\n logging.info(\\\"State is changing for %s to %s\\\", name, now)\\n # for each tag lets do it\\n\\n task_client = tasks_v2.CloudTasksClient()\\n task = {\\n \\\"app_engine_http_request\\\": { # Specify the type of request.\\n \\\"http_method\\\": \\\"POST\\\",\\n \\\"relative_uri\\\": \\\"/tasks/change_state\\\",\\n }\\n }\\n parent = task_client.queue_path(\\n queue=\\\"zorya-tasks\\\",\\n project=utils.get_project_id(),\\n location=location.get_location(),\\n )\\n for tag in policy.Tags:\\n for project in policy.Projects:\\n payload = {\\n \\\"project\\\": project,\\n \\\"tagkey\\\": next(iter(tag)),\\n \\\"tagvalue\\\": tag[next(iter(tag))],\\n \\\"action\\\": str(now),\\n }\\n task[\\\"app_engine_http_request\\\"][\\\"body\\\"] = (\\n json.dumps(payload)\\n ).encode()\\n response = task_client.create_task(parent, task)\\n logging.debug(\\\"Task %s enqueued\\\", response.name)\\n return \\\"ok\\\", 200\",\n \"def payment_success(request):\\r\\n\\tsecret_key = settings.SELLER_KEY\\r\\n\\tpid = request.GET['pid']\\r\\n\\tref = request.GET['ref']\\r\\n\\tresult = request.GET['result']\\r\\n\\t# Retrieve the cheksum value and validate it\\r\\n\\tchecksumstr = \\\"pid={}&ref={}&result={}&token={}\\\".format(pid, ref, result, secret_key)\\r\\n\\tm = md5(checksumstr.encode(\\\"ascii\\\"))\\r\\n\\tchecksum = m.hexdigest()\\r\\n\\tmalformed = False\\r\\n\\tprint(\\\"calculated: \\\" + checksum)\\r\\n\\tprint(\\\"received: \\\" + request.GET['checksum'] )\\r\\n\\tif (checksum == request.GET['checksum'] ):\\r\\n\\t\\ttransaction = Transaction.objects.get(pk=pid)\\r\\n\\t\\ttransaction.state = Transaction.CONFIRMED\\r\\n\\t\\ttransaction.reference = ref\\r\\n\\t\\tgame = Game.objects.get(id = transaction.game.id)\\r\\n\\t\\ttransaction.save()\\r\\n\\t\\tinc_purchase = game.purchase_number + 1\\r\\n\\t\\tgame.purchase_number = inc_purchase\\r\\n\\t\\tgame.save()\\r\\n\\t\\tprint(\\\"about to call success\\\")\\r\\n\\t\\treturn render(request, 'success.html', {'game': game, 'MEDIA_URL': settings.MEDIA_URL, 'malformed': malformed})\\r\\n\\telse:\\r\\n\\t\\ttransaction = Transaction.objects.get(pk=pid)\\r\\n\\t\\ttransaction.delete()\\r\\n\\t\\tmalformed = True\\r\\n\\t\\treturn render(request, 'success.html', {\\\"malformed\\\": malformed})\",\n \"def verify(self, request):\\n paypalURL = 'https://www.sandbox.paypal.com/cgi-bin/webscr'\\n if not self.SANDBOX:\\n paypalURL = 'https://www.paypal.com/cgi-bin/webscr'\\n\\n def _cb(response):\\n if response == 'INVALID':\\n raise PaypalError(\\n 'IPN data invalid. data: %s', (data,))\\n\\n elif response == 'VERIFIED':\\n return True\\n\\n else:\\n raise PaypalError('Unrecognized verification response: %s', (response,))\\n\\n data = request.content.read()\\n params = '?cmd=_notify-validate&' + data\\n\\n d = getPage(paypalURL+params, method='POST')\\n d.addCallback(_cb)\\n return d\",\n \"def __get_payment_details(self, token, PayerID):\\n request_params = {\\n 'METHOD': GET_CHECKOUT,\\n 'TOKEN': token,\\n }\\n\\n response = self.__do_request(request_params)\\n\\n if response['ACK'] == RESPONSE_OK:\\n return self.__capture_payment(response)\\n\\n return redirect(url_for('payment.error_payment',\\n payment_method=self.method_name))\",\n \"def test_process_postpay_accepted(self):\\r\\n student1 = UserFactory()\\r\\n student1.save()\\r\\n\\r\\n order1 = Order.get_cart_for_user(student1)\\r\\n params = {\\r\\n 'card_accountNumber': '1234',\\r\\n 'card_cardType': '001',\\r\\n 'billTo_firstName': student1.first_name,\\r\\n 'orderNumber': str(order1.id),\\r\\n 'orderCurrency': 'usd',\\r\\n 'decision': 'ACCEPT',\\r\\n 'ccAuthReply_amount': '0.00'\\r\\n }\\r\\n result = process_postpay_callback(params)\\r\\n self.assertTrue(result['success'])\\r\\n self.assertEqual(result['order'], order1)\\r\\n order1 = Order.objects.get(id=order1.id) # reload from DB to capture side-effect of process_postpay_callback\\r\\n self.assertEqual(order1.status, 'purchased')\\r\\n self.assertFalse(result['error_html'])\",\n \"def test_postflight_page_status(self):\\n response = self.client.get('/postflight/')\\n self.assertEqual(response.status_code, 200)\",\n \"def verify_payment(self, order_id, ref_id):\\n try:\\n client = Client(self.service_address)\\n res = client.service.bpVerifyRequest(terminalId=self.terminalId,\\n userName=self.userName,\\n userPassword=self.userPassword,\\n orderId=order_id,\\n saleOrderId=order_id,\\n saleReferenceId=ref_id)\\n return True, res\\n except WebFault as f:\\n return False, f.fault.faultstring\\n except Exception as e:\\n return False, e.message\",\n \"def checkState(self, desiredPage):\\n try:\\n # page = self.driver.find_elements_by_tag_name(\\\"h1.title\\\")\\n page = self.driver.find_element(\\n By.XPATH, \\\"/html/body/main/section/section/div[1]/h1\\\").text\\n page = str(page)\\n page = page.lower()\\n\\n if (desiredPage == \\\"watchlist\\\"):\\n if (page == \\\"transfer targets\\\"):\\n return True\\n else:\\n log_event(\\n self.queue, \\\"Unexpectedly not on Watchlist, stopping\\\")\\n return False\\n\\n elif (desiredPage == \\\"transfermarket\\\"):\\n if (page == \\\"search results\\\"):\\n return True\\n else:\\n log_event(\\n self.queue, \\\"Unexpectedly not on Transfer Market, stopping\\\")\\n return False\\n\\n elif (desiredPage == \\\"transferlist\\\"):\\n if (page == \\\"transfer list\\\"):\\n return True\\n else:\\n log_event(\\n self.queue, \\\"Unexpectedly not on Transfer list, stopping\\\")\\n return False\\n else:\\n log_event(self.queue, \\\"checkState was passed invalid location\\\")\\n except:\\n log_event(self.queue, \\\"Error checking state\\\")\",\n \"def check_validity(request_id):\\n return {\\n \\\"action\\\": \\\"PAYMENT_ACCEPTED\\\",\\n \\\"message\\\": {\\n \\\"status\\\": \\\"OK\\\",\\n \\\"request\\\": int(request_id)\\n }\\n }\",\n \"def get_razorpay_transaction_status(transaction_id):\\n global RazorPayClient\\n return RazorPayClient.order.fetch(transaction_id)['status']\",\n \"def test_successful_create_payment_payu_pln(self):\\n order = Order(name='Test PLN order', total=100, currency='PLN')\\n order.save()\\n response = self.client.post(reverse('getpaid-new-payment', kwargs={'currency' : 'PLN'}),\\n {'order': order.pk,\\n 'backend': 'getpaid.backends.payu'}\\n )\\n self.assertEqual(response.status_code, 302)\\n Payment = get_model('getpaid', 'Payment')\\n payment = Payment.objects.get(order=order.pk)\\n self.assertEqual(payment.backend, 'getpaid.backends.payu')\\n self.assertEqual(payment.amount, order.total)\\n self.assertEqual(payment.currency, order.currency)\\n self.assertEqual(payment.status, 'in_progress')\\n self.assertEqual(payment.paid_on, None)\\n self.assertEqual(payment.amount_paid, 0)\",\n \"def get_site_status(url):\\n repCode=None\\n\\n if url is \\\"\\\":\\n return(\\\"Not Valid\\\")\\n\\n try:\\n t1 = datetime.now()\\n response = get_response(url)\\n t2 = datetime.now()\\n\\n elapsed = t2-t1\\n\\n retTime = elapsed.microseconds\\n\\n repCode = getattr(response, 'status')\\n\\n logResponse(url,repCode,\\\"\\\",str(retTime))\\n\\n if repCode == 200:\\n return 'up'\\n except Exception as e:\\n logResponse(url,repCode,e)\\n pass\\n return 'down'\",\n \"def test_specific_peer_status(self):\\n ps2_status = self.pybird.get_peer_status(\\\"PS2\\\")\\n self.assertTrue(ps2_status['up'])\\n\\n # The test data says 14:20, so that could be today or yesterday\\n now = datetime.now()\\n expected_date = datetime(now.year, now.month, now.day, 14, 20)\\n if now.hour < 14 or now.hour == 14 and now.minute < 20:\\n expected_date = expected_date - timedelta(days=1)\\n self.assertEquals(ps2_status['last_change'], expected_date)\\n\\n self.assertEquals(ps2_status['state'], \\\"Established\\\")\\n self.assertEquals(ps2_status['routes_imported'], 24)\\n self.assertEquals(ps2_status['routes_exported'], 23)\\n self.assertEquals(ps2_status['import_updates_received'], 12)\\n self.assertEquals(ps2_status['import_withdraws_accepted'], 3)\\n self.assertEquals(ps2_status['export_updates_rejected'], 12)\\n self.assertEquals(ps2_status['router_id'], \\\"85.184.4.5\\\")\\n\\n ps1_status = self.pybird.get_peer_status(\\\"PS1\\\")\\n self.assertFalse(ps1_status['up'])\\n\\n self.assertEquals(ps1_status['last_change'], datetime(now.year, 6, 13))\\n\\n self.assertEquals(ps1_status['state'], \\\"Passive\\\")\",\n \"def alert_for_pending_invoices_1(request):\\n\\n\\tprint(\\\">>>>>>>>>>>>>>>>>>>>>Beginning of alert_for_pending_invoices_1<<<<<<<<<<<<<<<<<<<<\\\")\\n\\n\\tThread(target=alert_for_pending_invoices_1_woker).start()\\n\\n\\tprint(\\\">>>>>>>>>>>>>>>>>>>>>End of alert_for_pending_invoices_1<<<<<<<<<<<<<<<<<<<<\\\")\\n\\n\\tresponse = {}\\n\\n\\tresponse[\\\"info_to_contact\\\"] = \\\"Ok\\\"\\n\\n\\treturn response\",\n \"def check_new_payment_authcode(self, request: HttpRequest):\\n return self.check_authcode_params(\\n request,\\n (\\n \\\"RETURN_CODE\\\",\\n \\\"ORDER_NUMBER\\\",\\n \\\"SETTLED\\\",\\n \\\"CONTACT_ID\\\",\\n \\\"INCIDENT_ID\\\",\\n ),\\n )\",\n \"def update_payment_status(payment):\\n _assert_payment_is_yandex_kassa(payment)\\n yk_payment = api.get_payment_by_id(payment.gateway_payment_id)\\n _update_payment_status(payment, yk_payment)\",\n \"def get_gateway_url(self, request):\\n params = {\\n 'id': self.get_backend_setting('id'),\\n 'description': self.get_order_description(self.payment, self.payment.order),\\n 'amount': self.payment.amount,\\n 'currency': self.payment.currency,\\n 'type': 0, # 0 = show \\\"return\\\" button after finished payment\\n 'control': self.payment.pk,\\n 'URL': self.get_URL(self.payment.pk),\\n 'URLC': self.get_URLC(),\\n 'api_version': 'dev',\\n }\\n\\n user_data = {\\n 'email': None,\\n 'lang': None,\\n }\\n signals.user_data_query.send(sender=None, order=self.payment.order, user_data=user_data)\\n\\n if user_data['email']:\\n params['email'] = user_data['email']\\n\\n if user_data['lang'] and user_data['lang'].lower() in self._ACCEPTED_LANGS:\\n params['lang'] = user_data['lang'].lower()\\n elif self.get_backend_setting('lang', False\\n ) and self.get_backend_setting('lang').lower() in self._ACCEPTED_LANGS:\\n params['lang'] = self.get_backend_setting('lang').lower()\\n\\n if self.get_backend_setting('onlinetransfer', False):\\n params['onlinetransfer'] = 1\\n if self.get_backend_setting('p_email', False):\\n params['p_email'] = self.get_backend_setting('p_email')\\n if self.get_backend_setting('p_info', False):\\n params['p_info'] = self.get_backend_setting('p_info')\\n if self.get_backend_setting('tax', False):\\n params['tax'] = 1\\n\\n gateway_url = self.get_backend_setting('gateway_url', self._GATEWAY_URL)\\n\\n if self.get_backend_setting('method', 'get').lower() == 'post':\\n return gateway_url, 'POST', params\\n elif self.get_backend_setting('method', 'get').lower() == 'get':\\n for key in params.keys():\\n params[key] = six.text_type(params[key]).encode('utf-8')\\n return gateway_url + '?' + urlencode(params), \\\"GET\\\", {}\\n else:\\n raise ImproperlyConfigured('Dotpay payment backend accepts only GET or POST')\",\n \"def onCheckout(self, controller):\\n \\n if askokcancel(\\\"Proceed\\\", \\\"Pay the order?\\\"):\\n c = controller.customer\\n package = {'customer_id':c.id, 'order_price':c.my_order.GetTotalPrice}\\n msg = controller.transmit(package)\\n \\n if msg['order_received']:\\n c.CheckOut(c.my_order.GetTotalPrice)\\n c.Clear()\\n controller.show_frame(PageThree)\",\n \"def test_successful_create_payment_payu_pln(self):\\n order = Order(name='Test PLN order', total=100, currency='PLN')\\n order.save()\\n response = self.client.post(reverse('getpaid-new-payment', kwargs={'currency': 'PLN'}),\\n {'order': order.pk,\\n 'backend': 'getpaid.backends.payu'}\\n )\\n self.assertEqual(response.status_code, 302)\\n Payment = apps.get_model('getpaid', 'Payment')\\n payment = Payment.objects.get(order=order.pk)\\n self.assertEqual(payment.backend, 'getpaid.backends.payu')\\n self.assertEqual(payment.amount, order.total)\\n self.assertEqual(payment.currency, order.currency)\\n self.assertEqual(payment.status, 'in_progress')\\n self.assertEqual(payment.paid_on, None)\\n self.assertEqual(payment.amount_paid, 0)\",\n \"def accept_license():\\r\\n msg, status = \\\"\\\", True\\r\\n\\r\\n try:\\r\\n sleep(5)\\r\\n if g.platform == 'android':\\r\\n sleep(3)\\r\\n 'Click on license accept button'\\r\\n flag1 = ui_controls.button(get_obj_identifier('license_accept_btn'))\\r\\n \\r\\n \\r\\n\\r\\n status = False if not (flag1) else True\\r\\n else:\\r\\n \\r\\n 'Click on Agree button in EULA page for IOS'\\r\\n flag = ui_controls.button(get_obj_identifier('license_accept_btn'))\\r\\n status = flag\\r\\n\\r\\n except Exception as excp:\\r\\n traceback.print_exc()\\r\\n msg += str(excp)\\r\\n status = False\\r\\n\\r\\n return status, msg\",\n \"def paypal_gateway(self):\\n\\n print(request.form)\\n\\n # Gather information from callback response\\n first_name = request.form.get(\\\"first_name\\\", None)\\n last_name = request.form.get(\\\"last_name\\\", None)\\n payer_id = request.form.get(\\\"payer_id\\\", None)\\n payer_email = request.form.get(\\\"payer_email\\\", None)\\n item_name = request.form.get(\\\"item_name\\\", None)\\n item_number = request.form.get(\\\"item_number\\\", None)\\n custom = request.form.get(\\\"custom\\\", None)\\n payment_gross = request.form.get(\\\"payment_gross\\\", None)\\n\\n ## Generate Token and store in database\\n gen_uuid = str(uuid.uuid4())\\n\\n try:\\n t = Token()\\n t.uuid = gen_uuid\\n t.email = payer_email\\n t.active = True\\n t.package = item_name\\n t.package_id = item_number\\n\\n db.session.add(t)\\n db.session.commit()\\n except:\\n import traceback\\n db.session.rollback()\\n traceback.print_exc()\\n\\n ## Send email to user with unique link\\n try:\\n msg = Message(\\n \\\"Guildbit - Order Confirmation\\\",\\n sender=settings.DEFAULT_MAIL_SENDER,\\n recipients=[payer_email])\\n\\n msg.html = render_template(\\\"emails/payment_thankyou.html\\\", package=item_name, uuid=gen_uuid)\\n mail.send(msg)\\n except:\\n import traceback\\n traceback.print_exc()\\n\\n return jsonify({\\n \\\"status\\\": \\\"received\\\"\\n })\",\n \"def waiting_confirmation(self):\",\n \"def checkout(driver, user_details) -> None:\\n\\t\\n\\t# wait until checkout page loads\\n\\ttry: # look for twitter button as indicator of load\\n\\t\\twait = WebDriverWait(driver, 10)\\n\\t\\telement = wait.until(EC.element_to_be_clickable(\\n\\t\\t\\t(By.XPATH, \\\"//a[@href='https://twitter.com/tendmoney']\\\")))\\n\\texcept NoSuchElementException: # page didn't load in a reasonable amount of time\\n\\t\\tmanual_takeover() # swap to manual mode\\n\\t# fill out checkout details\\n\\tdriver.find_element_by_id(\\\"billing_first_name\\\").send_keys(user_details[0]) # first name\\n\\tdriver.find_element_by_id(\\\"billing_last_name\\\").send_keys(user_details[1]) # last name\\n\\tdriver.find_element_by_id(\\\"ak_venmo\\\").send_keys(user_details[2]) # venmo username\\n\\tdriver.find_element_by_id(\\\"billing_email\\\").send_keys(user_details[3]) # email address\\n\\t# switch to popup/new page (https://stackoverflow.com/a/29052586/4513452)\\n\\t# try: # look for clear cart button as indicator of load\\n\\t# \\twait = WebDriverWait(driver, 15)\\n\\t# \\t# not working even though i swear it's right\\n\\t# \\t# element = wait.until(EC.element_to_be_clickable(\\n\\t# \\t# \\t(By.XPATH, '/html/body/div[1]/div/div[1]/div')))\\n\\t# \\telement = wait.until(EC.element_to_be_clickable(\\n\\t# \\t\\t(By.XPATH, \\\"//a[contains(text(), 'Clear Cart')]\\\")))\\n\\t# except: # page didn't load in a reasonable amount of time\\n\\t# \\tmanual_takeover() # swap to manual mode\\n\\t# driver.find_element_by_xpath('/html/body/div[1]/div/div[1]/div').click() # click pay\\n\\ttime.sleep(10) # i have no idea why this ^ shit doesn't work, f this\\n\\t# this is so janky lol don't tell anyone\\n\\tdriver.find_element_by_id(\\\"billing_email\\\").click() # click email address\\n\\tdriver.find_element_by_id(\\\"billing_email\\\").send_keys(Keys.TAB) # tab over to paypal\\n\\tActionChains(driver).key_down(Keys.RETURN).key_up(Keys.RETURN).perform() # hit enter\\n\\t# driver.find_element_by_xpath(\\\"/html\\\").send_keys(Keys.RETURN) # hit enter on paypal\\n\\ttime.sleep(10)\\n\\t# try: # look for overlay as indicator of load\\n\\t# \\twait = WebDriverWait(driver, 15)\\n\\t# \\telement = wait.until(EC.element_to_be_clickable(\\n\\t# \\t\\t(By.XPATH, \\\"//a[contains(text(), 'Click to Continue')]\\\")))\\n\\t# except: # page didn't load in a reasonable amount of time\\n\\t# \\tmanual_takeover() # swap to manual mode\\n\\tmain_window_handle = driver.window_handles[0] # get main window handle for later\\n\\tpaypal_window_handle = driver.window_handles[1] # get paypal popup handle\\n\\t# print(\\\"pp handle: \\\", paypal_window_handle)\\n\\tdriver.switch_to.window(paypal_window_handle) # focus on popup\\n\\ttry: # look for final payment button as indicator of load\\n\\t\\twait = WebDriverWait(driver, 25)\\n\\t\\telement = wait.until(EC.element_to_be_clickable(\\n\\t\\t\\t(By.ID, \\\"payment-submit-btn\\\")))\\n\\texcept NoSuchElementException: # page didn't load in a reasonable amount of time\\n\\t\\tmanual_takeover() # swap to manual mode\\n\\t# testing\\n\\t# pp = driver.find_element_by_id(\\\"payment-submit-btn\\\") # .click()\\n\\t# print(\\\"pp: \\\", pp) # dont want to actually check out during testing\\n\\t# real checkout\\n\\tdriver.find_element_by_id(\\\"payment-submit-btn\\\").click()\",\n \"def payment_confirmation(self, **post):\\n sale_order_id = view.session.get('sale_last_order_id')\\n partner_id = view.env.user.partner_id\\n if sale_order_id:\\n sale_order_id = view.env['sale.order'].sudo().browse(int(sale_order_id))\\n lines = sale_order_id.order_line\\n policy_line = view.env['policies.holder.line']\\n for line in lines:\\n code = ''.join(random.choice('0123456789ABCDEF') for i in range(16))\\n policy_line.sudo().create({'name':lines.product_id.id, \\n 'premium':lines.price_unit, \\n 'policy_code':code, \\n 'line_id':partner_id.id,\\n 'start_date':Datetime.now(), 'end_date':Datetime.to_string(timedelta(days=lines.product_id.policy_period*360)+ datetime.now())})\\n s = super(InsuranceWebsiteSale, self).payment_confirmation()\\n view.session['sale_last_order_id'] = False\\n return s\\n return\",\n \"def trail_balance(self, pk, request):\\n try:\\n # Checking Token Authentication available\\n auth_info = AccountingOauth2.objects.filter(company_id=pk).values('accessToken', 'accessSecretKey',\\n 'tokenAcitvatedOn', 'tokenExpiryON')\\n secret_keys = Utils.get_access_keys(pk)\\n if len(auth_info) == 0:\\n return Utils.dispatch_failure(request, \\\"NO_TOKEN_AUTHENTICATION\\\")\\n\\n for key, value in auth_info[0].items():\\n OAUTH_PERSISTENT_SERVER_STORAGE.update({key: value})\\n stored_values = OAUTH_PERSISTENT_SERVER_STORAGE\\n\\n if len(stored_values) == 0:\\n return Utils.dispatch_failure(request, \\\"NO_TOKEN_AUTHENTICATION\\\")\\n\\n\\n # Checking Xero Connection Authentication available\\n auth = Utils.get_xero_auth(pk)\\n\\n if AccountingConfiguration.PRIVATE == secret_keys.type:\\n credentials = PrivateCredentials(**auth)\\n else:\\n credentials = PublicCredentials(**auth)\\n\\n if credentials.expired() or credentials is None:\\n return Utils.dispatch_failure(request, \\\"NO_TOKEN_AUTHENTICATION\\\")\\n\\n try:\\n xero = Xero(credentials)\\n xero.reports.get('TrialBalance')\\n\\n except XeroException as e:\\n if AccountingConfiguration.PRIVATE == secret_keys.type:\\n error = [\\\"%s\\\" % e]\\n return Utils.dispatch_failure(request, 'XERO_CONNECTION_ERROR', error)\\n else:\\n return Utils.dispatch_failure(request, \\\"NO_TOKEN_AUTHENTICATION\\\")\\n try:\\n meta = CompanyMeta.objects.filter(company_id=pk).first()\\n if meta.monthly_reporting_current_period:\\n st = time.time()\\n from portalbackend.lendapi.v1.accounting.tasks import trial_balance_for_period\\n job = group(trial_balance_for_period.s(pk, i) for i in range(0, 23))\\n result = job.apply_async()\\n else:\\n return Utils.dispatch_failure(request, 'MISSING_MONTHLY_REPORTING_CURRENT_PERIOD')\\n\\n while not result.ready():\\n continue\\n return Utils.dispatch_success(request, 'TRIAL_BALANCE_RECEIVED_SUCCESS')\\n except Exception as e:\\n error = [\\\"%s\\\" % e]\\n return Utils.dispatch_failure(request, 'DATA_PARSING_ISSUE', error)\\n except Exception as e:\\n return Utils.dispatch_failure(request, \\\"INTERNAL_SERVER_ERROR\\\")\",\n \"def payment(request,game_id):\\r\\n\\tgame = Game.objects.get(id = game_id)\\r\\n\\tif(game is not None): #check if the game exists\\r\\n\\t\\tcheck_if_bought = Transaction.objects.filter(payer = request.user.profile,game=Game.objects.get(id=game_id),state=Transaction.CONFIRMED).count() #check if user has already purchased the game\\r\\n\\t\\tif check_if_bought > 0 or game.developer == request.user.profile:\\r\\n\\t\\t\\treturn redirect(\\\"/play/\\\" + str(game_id))\\r\\n\\t\\tpurchase_game = Game.objects.get(id = game_id)\\r\\n\\t\\tnew_payer = Profile.objects.get(user = request.user)\\r\\n\\t\\tnew_payee= purchase_game.developer\\r\\n\\t\\ttransaction = Transaction.objects.create(payer=new_payer, payee= new_payee, game=purchase_game,amount=purchase_game.price)\\r\\n\\t\\ttransaction.save()\\r\\n\\t\\t# Generate checksum and hash values\\r\\n\\t\\tchecksumstr = \\\"pid={}&sid={}&amount={}&token={}\\\".format(transaction.id, settings.SELLER_ID, purchase_game.price, settings.SELLER_KEY)\\r\\n\\t\\tm = md5(checksumstr.encode(\\\"ascii\\\"))\\r\\n\\t\\tchecksum = m.hexdigest()\\r\\n\\r\\n\\t\\tprint(transaction.id, transaction.state, checksumstr)\\r\\n\\t\\treturn render(request, 'payment.html', {'game':purchase_game,'SELLER_ID':settings.SELLER_ID, 'MEDIA_URL': settings.MEDIA_URL, 'transaction': transaction, 'checksum': checksum})\\r\\n\\telse:\\r\\n\\t\\treturn redirect('home') # Redirect to home if link is faulty\\r\",\n \"def check(self):\\n\\n print('Requester object is active: \\\\t', str(self.is_active))\\n print('Number of requests sent: \\\\t', str(self.n_requests))\\n print('Requester opened: \\\\t\\\\t', str(self.st_time))\\n print('Requester closed: \\\\t\\\\t', str(self.en_time))\",\n \"def get_status(self):\\n\\t\\treturn call_sdk_function('PrlLic_GetStatus', self.handle)\",\n \"def test_list_scheduled_payments(self):\\n pass\",\n \"def update_paypal(sender, **kwargs):\\n ipn_obj = sender\\n try:\\n payment = json.loads(ipn_obj.custom)\\n\\n # try to get payment. if not exist, exception will be catched\\n p = Payment.objects.filter(id=payment.get('id'), token=payment.get('token')).get()\\n\\n # update payment\\n p.method = constants.PAYPAL\\n p.ipn = ipn_obj\\n p.save()\\n\\n # if payment is completed, so valid\\n if ipn_obj.payment_status == ST_PP_COMPLETED:\\n # check correct price , currency and mail\\n if int(ipn_obj.mc_gross) == int(p.price.price) and \\\\\\n ipn_obj.mc_currency == 'EUR' and \\\\\\n ipn_obj.business == settings.PAYPAL_RECEIVER_EMAIL:\\n # all is OK, update state\\n p.state = True\\n p.save()\\n sendmail_payment_success(p)\\n else:\\n # TODO: send alert / mail\\n return\\n except Payment.DoesNotExist:\\n # TODO: send alert / mail\\n pass\\n except:\\n # TODO: send alert / mail\\n pass\",\n \"def pp_confirm_payment_interactive(self, approval_url):\\n from selenium import webdriver\\n from selenium.webdriver.common.keys import Keys\\n display = Display(visible=0, size=(800,600))\\n display.start()\\n br = webdriver.Firefox()\\n br.get(approval_url)\\n e = br.find_element_by_id('loadLogin')\\n e.click()\\n e = br.find_element_by_id('login_email')\\n e.send_keys(settings.PAYPAL_TESTUSER)\\n e = br.find_element_by_id('login_password')\\n e.send_keys(settings.PAYPAL_TESTUSER_PASSWORD)\\n e = br.find_element_by_id('submitLogin')\\n e.click()\\n e = br.find_element_by_id('continue')\\n e.click()\\n # response url is of the form\\n # http://<return_url>?paymentId=PAY-6RV70583SB702805EKEYSZ6Y&token=EC-60U79048BN7719609&PayerID=7E7MGXCWTTKK2\\n # see https://developer.paypal.com/docs/integration/web/accept-paypal-payment/#get-payment-approval\\n response_url = br.current_url\\n parts = urlparse.urlparse(response_url)\\n authorization = urlparse.parse_qs(parts.query)\\n br.get_screenshot_as_file('payment.png')\\n br.quit()\\n display.stop()\\n return authorization\",\n \"def paynova_callback(request):\\n\\n log.info('Callback. %s ' % request.POST)\\n\\n # check DIGEST\\n\\n if not _ehn_checksum(request.POST):\\n log.error('EHN DIGEST hash is not verified. %s' % request.POST)\\n return HttpResponseBadRequest()\\n\\n # check EVENT_TYPE\\n # TODO: process other events\\n\\n if request.POST.get('EVENT_TYPE') != 'PAYMENT':\\n log.error('Unexpected EVENT_TYPE. %s' % request.POST)\\n return HttpResponseBadRequest()\\n\\n # get PaynovaPayment from model\\n\\n try:\\n pp = PaynovaPayment.objects.get(order_id=request.POST.get('ORDER_ID'), session_id=request.POST.get('SESSION_ID'))\\n except PaynovaPayment.DoesNotExist:\\n log.error('Unknown ORDER_ID. %s' % request.POST)\\n return HttpResponseNotFound()\\n\\n pp.status = request.POST.get('PAYMENT_STATUS')\\n pp.status_reason = request.POST.get('PAYMENT_STATUS_REASON')\\n pp.params_ehn = request.POST\\n pp.save()\\n\\n # send signal\\n\\n log.debug('Process paynova_payment signal')\\n\\n paynova_payment.send(sender=pp, params=request.POST, status=request.POST.get('PAYMENT_STATUS'))\\n\\n log.debug('Signal paynova_payment processed')\\n\\n return HttpResponse()\",\n \"def _verify_page(self):\",\n \"def order_success(request, job_id, token):\\n if request.user.is_active:\\n job_obj = Job.objects.get(job_id= job_id)\\n if job_obj.employeer == request.user:\\n if verifiers.payment_token_is_valid(token, job_obj):\\n if job_obj.accepted == False:\\n job_obj.status = Status.objects.create(status_name=\\\"PN\\\", comment=\\\"Awaiting payment confirmation from Stripe, this might take a few minutes.\\\")\\n job_obj.accepted = True\\n job_obj.save()\\n \\n messages.add_message(request, messages.INFO, 'Your order has been created.')\\n return redirect('/') \\n else:\\n #someone tries to manually enter the URL with wrong payment_token\\n messages.add_message(request, messages.INFO, 'Something went wrong, try again later.') \\n return redirect(\\\"/\\\") \\n else:\\n #the person making the request is not the same as the person who created the job\\n messages.add_message(request, messages.INFO, 'Something went wrong, try again later.') \\n return redirect(\\\"/\\\") \\n else:\\n return redirect(\\\"/login\\\")\",\n \"def click_submit_payment_button(self):\\n self.click(self.submit_payment_locator)\\n time.sleep(2)\",\n \"async def verify(self, payee, paid_for, guild_id, amount, message_id):\\n\\n collection = self.db[str(guild_id)]\\n\\n payee_doc = await collection.find_one({'id': payee.id})\\n paid_for_doc = await collection.find_one({'id': paid_for.id})\\n values = payee_doc['data']\\n paid_for_values = paid_for_doc['data']\\n if not self.unapproved(paid_for_doc, message_id):\\n return\\n\\n if list(values.keys()).count(str(paid_for.id)) > 0:\\n values[str(paid_for.id)] = values[str(paid_for.id)] + amount\\n else:\\n values[str(paid_for.id)] = amount\\n\\n '''Adding payment in paid_for's collection'''\\n\\n if list(paid_for_values.keys()).count(str(payee.id)) > 0:\\n paid_for_values[str(payee.id)] = paid_for_values[str(payee.id)] - amount\\n else:\\n paid_for_values[str(payee.id)] = - amount\\n\\n await collection.update_one({'id': paid_for.id}, {'$set': {'data': paid_for_values}})\\n\\n '''Adding payment in payee's collection'''\\n await collection.update_one({'id': payee.id}, {'$set': {'data': values}})\\n\\n \\\"\\\"\\\"Decreasing value of left verifications from DB\\\"\\\"\\\"\\n unverified = payee_doc['unverified']\\n verified = None\\n for message in unverified:\\n if message['Mid'] == message_id:\\n verified = message\\n break\\n if verified['left'] == 1:\\n unverified.remove(verified)\\n else:\\n verified['left'] -= 1\\n\\n await collection.update_one({'id': payee.id}, {'$set': {'unverified': unverified}})\\n\\n \\\"\\\"\\\"Removing unapproved from paid_for's DB\\\"\\\"\\\"\\n unapproved = paid_for_doc['unapproved']\\n approved = None\\n for message in unapproved:\\n if message['Mid'] == message_id:\\n approved = message\\n break\\n\\n unapproved.remove(approved)\\n await collection.update_one({'id': paid_for.id}, {'$set': {'unapproved': unapproved}})\",\n \"def status():\\n\\n header(title=\\\"Site Status\\\", domain_name=domain_name)\\n\\n if not client.site_exists:\\n site_404_message(config.get(\\\"domain\\\"))\\n footer()\\n return\\n\\n print(\\\"---\\\")\\n print(\\\"URL : %s \\\" % client.domain_url)\\n \\n print(\\\"---\\\")\\n print(\\\"S3\\\")\\n print(\\\"Site created: %s \\\" % ('OK' if client.site_exists else 'Failed'))\\n print(\\\"URL : %s \\\" % client.s3_url)\\n\\n if distribution != \\\"s3\\\":\\n print(\\\"---\\\")\\n print(\\\"ACM\\\")\\n print(\\\"Certificate status: %s \\\" % client.acm_get_certificate_status())\\n\\n print(\\\"---\\\")\\n print(\\\"Cloudfront\\\")\\n print(\\\"Distribution id: %s \\\" % client.cloudfront_get_distribution_id())\\n print(\\\"Domain name: %s \\\" % client.cloudfront_get_distribution_domain_name())\\n\\n ns_values = client.route53_get_ns_values()\\n if ns_values:\\n print(\\\"---\\\")\\n print(\\\"Name Servers\\\")\\n print((\\\"\\\\n\\\".join(ns_values)))\\n else:\\n print(\\\"Deployment: site is available from AWS S3 only\\\")\\n footer()\",\n \"def _update_payment_status(payment: Payment, yk_payment: PaymentResponse):\\n _assert_payment_is_yandex_kassa(payment)\\n\\n mapped_status = _YK_STATUS_MAPPING.get(yk_payment.status)\\n assert mapped_status, \\\\\\n f'Cannot map status {yk_payment.status} for {yk_payment}'\\n\\n # float because of https://github.com/yandex-money/yandex-checkout-sdk-python/pull/64\\n yk_amount = float(yk_payment.amount.value)\\n yk_currency = yk_payment.amount.currency\\n payment_amount = float(payment.amount.amount)\\n payment_currency = payment.amount.currency.code\\n\\n # Let's find out if there are some updates\\n need_save = False\\n if yk_amount != payment_amount:\\n logger.error(f'Incorrect amount {payment_amount} in Payment. Correcting it to {yk_amount}')\\n payment.amount = Money(yk_amount, yk_currency)\\n need_save = True\\n if yk_currency != payment_currency:\\n logger.error(f'Incorrect currency {payment_currency} in Payment. Correcting it to {yk_currency}')\\n payment.amount = Money(yk_amount, yk_currency)\\n need_save = True\\n\\n if payment.state != mapped_status:\\n payment.state = mapped_status\\n need_save = True\\n\\n if need_save:\\n logger.info(f'Updating payment {payment}')\\n payment.save()\\n else:\\n logger.debug(f'No need to update {payment}')\",\n \"def verify(self, response):\",\n \"def test_get_virtual_account_payments(self):\\n pass\",\n \"def verify_farmer_payment(self, payment_id, pay_status):\\n if not self.this_user:\\n return self.return_data(401, \\\"Current user not set\\\", {})\\n\\n payment_info = self.get_a_payment(payment_id)\\n loan_owner = {}\\n if payment_info:\\n loan_owner = self.get_loan_owner(payment_info[\\\"loan_id\\\"])\\n is_incharge = False\\n is_manager = False\\n if len(loan_owner) > 0:\\n is_incharge = self.is_farmers_agent(\\n self.this_user[\\\"username\\\"], loan_owner[\\\"username\\\"]\\n )\\n if self.this_user[\\\"role\\\"] == \\\"CREDIT_MANAGER\\\":\\n is_manager = True\\n\\n if (is_incharge or is_manager):\\n q_list = []\\n query = self.update_query(\\n \\\"payments\\\", \\\"approved\\\", pay_status,\\n \\\"payment_id\\\", payment_id\\n )\\n q_list.append(query)\\n reply = self.save_data(q_list)\\n if isinstance(reply, bool):\\n reply = self.get_a_payment(payment_id)\\n reply[\\\"amount_paid\\\"] = str(reply[\\\"amount_paid\\\"])\\n return self.return_data(200, \\\"SUCCESS\\\", reply)\\n return self.return_data(400, \\\"BAD REQUEST\\\", reply)\\n return self.return_data(401, \\\"UNAUTHRIZED\\\", {})\",\n \"def make_payment():\\n\\n response = VoiceResponse()\\n if 'caller_name' not in session:\\n session['caller_name'] = request.args.get(\\n 'caller_name') or \\\"Twilio Payment\\\"\\n if 'payment_amount' not in session:\\n session['payment_amount'] = request.args.get('amount') or \\\"5000\\\"\\n if 'card_number' not in session:\\n response.redirect('/get_card_number')\\n elif 'expiry' not in session:\\n response.redirect('/get_expiry')\\n elif 'cvv' not in session:\\n response.redirect('/get_cvv')\\n else:\\n call_sid = request.form.get('CallSid')\\n session['call_sid'] = call_sid\\n response.redirect('/process_payment')\\n\\n return str(response)\",\n \"def remote_status():\",\n \"def post(self, payment_id=None):\\n data = request.get_json()\\n redirect_url = data.get('redirect_url')\\n cart_token = data.get('cart_token')\\n address_id = data.get('address_id')\\n \\n cart = Cart.query.filter_by(token=cart_token, user_id=current_user.id).first()\\n if not cart:\\n return {\\\"message\\\":\\\"No cart with this id\\\"}, 404\\n\\n if not address_id:\\n return {\\\"message\\\": \\\"Please enter a address for your order\\\"}, 404\\n\\n order = Order.create_from_cart(cart_token, address_id)\\n payment = Payment.query.filter_by(order_id=order.id).first()\\n if not payment:\\n payment = Payment(\\n user_id=current_user.id, \\n order_id=order.id, \\n amount=order.total,\\n status='Pending'\\n )\\n\\n db.session.add(payment)\\n db.session.commit()\\n\\n client = Client(current_app.config['ZARINPAL_WEBSERVICE'])\\n mail = current_user._email\\n\\n if not mail:\\n return {\\\"message\\\": \\\"Please enter your email address to continue the payment\\\"}\\n\\n user_info = UserAddress.query.filter_by(id=address_id).first()\\n if user_info.phone:\\n mobile = user_info.phone\\n else:\\n mobile = '' \\n\\n result = client.service.PaymentRequest(current_app.config['MERCHANT_ID'],\\n payment.amount,\\n 'nani',\\n mail,\\n mobile,\\n redirect_url)\\n\\n payment.authority = result.Authority\\n db.session.commit()\\n if result.Status == 100:\\n return {'payment_url':'https://www.zarinpal.com/pg/StartPay/' + result.Authority}\\n else:\\n return {\\n 'message':\\\"We can't connect you to zarin pal server, right now. Please try again in a few moments.\\\"\\n }, 404\",\n \"def you_win(request):\\n # filter originals by paid is false and auction is closed\\n now = datetime.now()\\n auction_items_to_be_paid = Original.objects.exclude(end_date_time__lte=now, paid=\\\"True\\\")\\n if not auction_items_to_be_paid:\\n redirect(reverse(originals)) \\n # if it is empty, then redirect to auctions.html\\n\\n return render(request, 'youwin.html', { 'auction_items_to_be_paid': auction_items_to_be_paid })\",\n \"def process_postpay_callback(params):\\r\\n try:\\r\\n verify_signatures(params)\\r\\n result = payment_accepted(params)\\r\\n if result['accepted']:\\r\\n # SUCCESS CASE first, rest are some sort of oddity\\r\\n record_purchase(params, result['order'])\\r\\n return {'success': True,\\r\\n 'order': result['order'],\\r\\n 'error_html': ''}\\r\\n else:\\r\\n return {'success': False,\\r\\n 'order': result['order'],\\r\\n 'error_html': get_processor_decline_html(params)}\\r\\n except CCProcessorException as error:\\r\\n return {'success': False,\\r\\n 'order': None, # due to exception we may not have the order\\r\\n 'error_html': get_processor_exception_html(error)}\",\n \"def scrapeFollowingFromAnAccount():\\n global api\",\n \"def send_verification(self):\\n pass\",\n \"def evaluate_cancellation_pending_due_to_non_pay(self, date_cursor=None):\\n\\n if not date_cursor:\\n date_cursor = datetime.now().date()\\n\\n invoices = Invoice.query.filter_by(policy_id=self.policy.id)\\\\\\n .filter(Invoice.due_date <= date_cursor, date_cursor < Invoice.cancel_date)\\\\\\n .order_by(Invoice.bill_date)\\\\\\n .all()\\n\\n for invoice in invoices:\\n if not self.return_account_balance(invoice.cancel_date):\\n continue\\n else:\\n print \\\"THIS POLICY STATUS IS PENDING CANCELED\\\"\\n return True\\n break\\n else:\\n print \\\"THIS POLICY IS NOT PENDING CANCELED\\\"\\n\\n return False\",\n \"def test_payment(self):\\n debit_jobs([(self.job, A(480), Entry.WORK_DEBIT)])\\n credit_jobs([(self.job, A(480), A(0), A(0))], D(480))\\n self.assert_balances(\\n bank=A(480, 0, 0),\\n invoiced=A(480),\\n paid=A(-480),\\n partial=A(480).net_amount,\\n tax=A(480).tax_amount,\\n )\",\n \"def check_mitm_status_page(self, check_url):\\n response = requests.get(check_url)\\n if response.status_code == 200:\\n return response\\n else:\\n sys.exit(2)\",\n \"def _onSuccess(self, controller):\\r\\n if controller.order.paid_in_full:\\r\\n controller.cart.empty()\\r\\n for item in controller.order.orderitem_set.all():\\r\\n if item.product.is_subscription:\\r\\n item.completed = True\\r\\n item.save()\\r\\n try:\\r\\n curr_status = controller.order.orderstatus_set.latest() \\r\\n except OrderStatus.DoesNotExist:\\r\\n curr_status = None\\r\\n \\r\\n if (curr_status is None) or (curr_status.notes and curr_status.status == \\\"New\\\"):\\r\\n controller.order.add_status(status='New', notes = \\\"Order successfully submitted\\\")\\r\\n else:\\r\\n # otherwise just update and save\\r\\n if not curr_status.notes:\\r\\n curr_status.notes = _(\\\"Order successfully submitted\\\")\\r\\n curr_status.save() \\r\\n\\r\\n #Redirect to the success page\\r\\n url = controller.lookup_url('satchmo_checkout-success')\\r\\n return HttpResponseRedirect(url) \\r\\n\\r\\n else:\\r\\n log.debug('Order #%i not paid in full, sending to pay rest of balance', controller.order.id)\\r\\n #url = controller.order.get_balance_remaining_url()\\r\\n url = reverse('satchmo_balance_remaining')\\r\\n return HttpResponseRedirect(url)\",\n \"def collect_payment():\\n\\n # 1. Get required arguments\\n args = Eg014Controller.get_args()\\n try:\\n # 2. Call the worker method\\n results = Eg014Controller.worker(args)\\n except ApiException as err:\\n return process_error(err)\\n\\n # 3. Render success response\\n return render_template(\\n \\\"example_done.html\\\",\\n title=\\\"Envelope sent\\\",\\n h1=\\\"Envelope sent\\\",\\n message=f\\\"\\\"\\\"The envelope has been created and sent!<br/> Envelope ID {results[\\\"envelope_id\\\"]}.\\\"\\\"\\\"\\n )\",\n \"def update_payment_status(self):\\n payments = Payment.query.filter_by(invoice_id=self.id).all()\\n total = 0.0\\n for payment in payments:\\n total += float(payment.amount)\\n\\n if total >= self.total:\\n self.payment_status = u'paid'\\n else:\\n self.payment_status = u'unpaid'\\n\\n db.session.add(self)\\n db.session.commit()\\n\\n return False\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7122953","0.7110178","0.65054214","0.639817","0.61742175","0.61226845","0.6104691","0.5995269","0.5959673","0.5959388","0.5890821","0.57182485","0.5644974","0.5628669","0.5604625","0.5577589","0.55546874","0.55534333","0.55522","0.5548011","0.5545392","0.552988","0.5528792","0.5521078","0.5512806","0.55105513","0.5475784","0.54566854","0.5447763","0.54160213","0.5398339","0.5377852","0.5364757","0.53535897","0.53513414","0.53427315","0.5335829","0.5335227","0.5322198","0.5316201","0.5294779","0.5289074","0.52887815","0.5272839","0.52578306","0.5253822","0.5250126","0.52326065","0.5225852","0.52173495","0.52163553","0.5204199","0.51979375","0.51977473","0.51864517","0.5184967","0.5174017","0.5169424","0.5169291","0.51665765","0.5161012","0.515867","0.51563233","0.5151585","0.5142858","0.51334554","0.5127071","0.5115879","0.51120347","0.510804","0.51048","0.5093261","0.509119","0.50875276","0.5085412","0.5076873","0.50725526","0.5072018","0.50688124","0.50666934","0.5063673","0.5051251","0.5037087","0.50370234","0.50360155","0.5033316","0.50297993","0.5027292","0.501724","0.50157285","0.50069946","0.5003518","0.5001332","0.49980563","0.4996826","0.49964315","0.49949318","0.49866322","0.4985535","0.49824813"],"string":"[\n \"0.7122953\",\n \"0.7110178\",\n \"0.65054214\",\n \"0.639817\",\n \"0.61742175\",\n \"0.61226845\",\n \"0.6104691\",\n \"0.5995269\",\n \"0.5959673\",\n \"0.5959388\",\n \"0.5890821\",\n \"0.57182485\",\n \"0.5644974\",\n \"0.5628669\",\n \"0.5604625\",\n \"0.5577589\",\n \"0.55546874\",\n \"0.55534333\",\n \"0.55522\",\n \"0.5548011\",\n \"0.5545392\",\n \"0.552988\",\n \"0.5528792\",\n \"0.5521078\",\n \"0.5512806\",\n \"0.55105513\",\n \"0.5475784\",\n \"0.54566854\",\n \"0.5447763\",\n \"0.54160213\",\n \"0.5398339\",\n \"0.5377852\",\n \"0.5364757\",\n \"0.53535897\",\n \"0.53513414\",\n \"0.53427315\",\n \"0.5335829\",\n \"0.5335227\",\n \"0.5322198\",\n \"0.5316201\",\n \"0.5294779\",\n \"0.5289074\",\n \"0.52887815\",\n \"0.5272839\",\n \"0.52578306\",\n \"0.5253822\",\n \"0.5250126\",\n \"0.52326065\",\n \"0.5225852\",\n \"0.52173495\",\n \"0.52163553\",\n \"0.5204199\",\n \"0.51979375\",\n \"0.51977473\",\n \"0.51864517\",\n \"0.5184967\",\n \"0.5174017\",\n \"0.5169424\",\n \"0.5169291\",\n \"0.51665765\",\n \"0.5161012\",\n \"0.515867\",\n \"0.51563233\",\n \"0.5151585\",\n \"0.5142858\",\n \"0.51334554\",\n \"0.5127071\",\n \"0.5115879\",\n \"0.51120347\",\n \"0.510804\",\n \"0.51048\",\n \"0.5093261\",\n \"0.509119\",\n \"0.50875276\",\n \"0.5085412\",\n \"0.5076873\",\n \"0.50725526\",\n \"0.5072018\",\n \"0.50688124\",\n \"0.50666934\",\n \"0.5063673\",\n \"0.5051251\",\n \"0.5037087\",\n \"0.50370234\",\n \"0.50360155\",\n \"0.5033316\",\n \"0.50297993\",\n \"0.5027292\",\n \"0.501724\",\n \"0.50157285\",\n \"0.50069946\",\n \"0.5003518\",\n \"0.5001332\",\n \"0.49980563\",\n \"0.4996826\",\n \"0.49964315\",\n \"0.49949318\",\n \"0.49866322\",\n \"0.4985535\",\n \"0.49824813\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6033519"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":24584,"cells":{"query":{"kind":"string","value":"Creates a new database session for a test."},"document":{"kind":"string","value":"def session(project, engine_sessionmaker, connection):\n _, Session = engine_sessionmaker\n\n try:\n session = Session(bind=connection)\n yield session\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 _initTestingDB(): \n from sqlalchemy import create_engine\n engine = create_engine('sqlite://')\n from .models import (\n Base,\n TodoUser,\n )\n DBSession.configure(bind=engine)\n Base.metadata.create_all(engine)\n \n return DBSession","def create_test_db(self, *args, **kw):\n self.destroy_test_db()\n self.connection.use_test_datastore = True\n self.connection.flush()","def create_new_test_session(name):\n now=datetime.datetime.now()\n is_over=0\n sql=\"INSERT INTO sessions(update_time,is_over,name,total_coverage) VALUES(?,?,?,?)\"\n execute_query(sql,(now,is_over,name,\"0\"))\n active_session=get_active_test_session()\n active_files=get_active_files()\n for f in active_files:\n sql=\"INSERT INTO sessions_files VALUES(?,?)\"\n execute_query(sql,(active_session[0],f[0]))","def create_new_session():\n database_engine = create_engine(SQLITE_FILE)\n DeclarativeBase.metadata.create_all(database_engine)\n DeclarativeBase.bind = database_engine\n\n session = sessionmaker()\n session.configure(bind=database_engine)\n\n return session()","def make_new_session():\n session = Session.objects.create(uuid=str(uuid4()), container_id=None)\n return session.id","def test_create_session(self):\n study_id = self.storage.create_study(sample_study_spec())\n\n session = sample_session(study_id=study_id)\n self.storage.create_session(session)\n\n self.assertEqual(self.storage.get_session(study_id, session.id), session)","def set_db_session():\n g.s = database.db_session()","def create_db_session():\n engine = engine = create_engine('sqlite:///budget.db')\n Base.metadata.bind = engine\n DBSession = sessionmaker(bind=engine)\n session = DBSession()\n return session","def db_session(configuration, request):\n SessionFactory = configuration.registry[\"dbsession_factory\"]\n session = SessionFactory()\n engine = session.bind\n Base.metadata.create_all(engine)\n\n def teardown():\n session.transaction.rollback()\n Base.metadata.drop_all(engine)\n\n request.addfinalizer(teardown)\n return session","def test_new_session_promotion(self):\r\n cursor = self.db.cursor()\r\n incookie = Cookie()\r\n incookie['trac_session'] = '123456'\r\n outcookie = Cookie()\r\n req = Mock(authname='john', base_path='/', incookie=incookie,\r\n outcookie=outcookie)\r\n session = Session(self.env, req)\r\n self.assertEqual('john', session.sid)\r\n session.save()\r\n\r\n cursor.execute(\"SELECT sid,authenticated FROM session\")\r\n self.assertEqual(('john', 1), cursor.fetchone())\r\n self.assertEqual(None, cursor.fetchone())","def start_session(db_path):\n engine = create_engine('sqlite:///' + db_path)\n Session = sessionmaker(bind=engine)\n return Session()","def create_session():\n session = Session()\n try:\n yield session\n session.commit()\n except:\n session.rollback()\n raise\n finally:\n session.close()","def prepare_database(config):\n global Session\n engine = sqlalchemy.create_engine(config.db_string)\n session_factory = sqlalchemy.orm.sessionmaker(bind=engine)\n Session = sqlalchemy.orm.scoped_session(session_factory)","def db_session(configuration, request):\n SessionFactory = configuration.registry['dbsession_factory']\n session = SessionFactory()\n engine = session.bind\n Base.metadata.create_all(engine)\n\n def teardown():\n session.transaction.rollback()\n Entries.__table__.drop(engine)\n\n request.addfinalizer(teardown)\n return session","def sess():\n engine = create_engine(\"sqlite://\", echo=True)\n with engine.begin() as conn:\n conn.execute(\"ATTACH DATABASE ':memory:' AS placebo\")\n Base.metadata.create_all(engine)\n sess = sessionmaker(bind=engine)()\n return sess","def session(request):\n session = get_test_db_session()\n request.cls.session = session\n return session","def get_or_create_session(db):","def _create_db_session(self):\r\n session = Session()\r\n try:\r\n yield session\r\n session.commit()\r\n except Exception:\r\n session.rollback()\r\n raise\r\n finally:\r\n session.close()","def db_session(configuration, request):\n session_factory = configuration.registry['dbsession_factory']\n session = session_factory()\n engine = session.bind\n Base.metadata.drop_all(engine)\n Base.metadata.create_all(engine)\n\n def teardown():\n session.transaction.rollback()\n\n request.addfinalizer(teardown)\n return session","def create_test_database(cls):\n from sqlalchemy import engine_from_config\n from tests.models import Base\n\n cls = AppTestCase # set class variables on superclass\n cls.settings = cls._read_pyramid_settings()\n cls.engine = engine_from_config(cls.settings, prefix=\"sqlalchemy.\")\n print(\"Creating the tables on the test database:\\n%s\" % cls.engine)\n Base.metadata.drop_all(cls.engine)\n Base.metadata.create_all(cls.engine)","def setUp(self):\n\n self.client = server.app.test_client()\n server.app.config['TESTING'] = True\n server.app.config['SECRET_KEY'] = \"123\"\n\n # Connect to test database\n model.connect_to_db(server.app, \"postgresql:///testdb\")\n\n # Create tables and add sample data\n model.db.create_all()\n # example_data()\n\n with self.client as c:\n with c.session_transaction() as session:\n session['user_id'] = 33\n session['username'] = 'balloonicorn'\n session['name'] = 'balloonicorn'","def database_session():\n if \"CI\" in os.environ:\n con = psycopg2.connect(\n host=os.environ[\"POSTGRES_HOST\"],\n port=os.environ[\"POSTGRES_PORT\"],\n user=os.environ[\"PGUSER\"],\n password=os.environ[\"PGPASSWORD\"],\n )\n else:\n con = psycopg2.connect(host=\"127.0.0.1\", port=\"5432\")\n # Setup\n con.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)\n cursor = con.cursor()\n cursor.execute(f'create database \"{DB}\";')\n session = Meta.init(CONN_STRING).Session()\n yield session\n\n # Teardown\n engine = session.get_bind()\n session.close()\n engine.dispose()\n Meta.engine = None\n\n cursor.execute(f'drop database \"{DB}\";')\n cursor.close()\n con.close()","def test_new_session(self):\r\n cookie = Cookie()\r\n req = Mock(incookie=Cookie(), outcookie=cookie, authname='anonymous',\r\n base_path='/')\r\n session = Session(self.env, req)\r\n self.assertEqual(session.sid, cookie['trac_session'].value)\r\n cursor = self.db.cursor()\r\n cursor.execute(\"SELECT COUNT(*) FROM session\")\r\n self.assertEqual(0, cursor.fetchone()[0])","def test_get_db_session(initialized_db_url):\n with utils.get_db_session(initialized_db_url) as db:\n assert isinstance(db, Session)","def setUp(self):\n\n self.client = server.app.test_client()\n server.app.config['TESTING'] = True\n server.app.config['SECRET_KEY'] = \"123\"\n\n # Connect to test database\n model.connect_to_db(server.app, \"postgresql:///testdb\")\n\n # Create tables and add sample data\n model.db.create_all()\n # example_data()\n\n with self.client as c:\n with c.session_transaction() as session:\n session['user_id'] = 1\n session['username'] = 'j'\n session['name'] = 'l'\n session['cal_id'] = 1","def database_session_wide(app) -> SQLAlchemy:\n if os.path.exists(get_test_database_path()):\n os.unlink(get_test_database_path())\n\n from pipwatch_api.datastore.models import DATABASE\n DATABASE.init_app(app=app)\n DATABASE.create_all()\n yield DATABASE\n\n DATABASE.drop_all()\n DATABASE.session.close()\n\n os.unlink(get_test_database_path())","def db_session(configuration, request):\n SessionFactory = configuration.registry['dbsession_factory']\n session = SessionFactory()\n engine = session.bind\n Base.metadata.drop_all(engine)\n Base.metadata.create_all(engine)\n\n def teardown():\n session.transaction.rollback()\n Base.metadata.drop_all(engine)\n\n request.addfinalizer(teardown)\n return session","def test_set_session():","def setup_session():\n print(\"Setting up session\")\n engine = setup_engine()\n Base.metadata.bin = engine\n\n DBSession = sessionmaker(bind=engine)\n session = DBSession()\n\n return session","def new_user(testapp):\n SessionFactory = testapp.app.registry[\"dbsession_factory\"]\n with transaction.manager:\n dbsession = get_tm_session(SessionFactory, transaction.manager)\n new_user = User(username=\"test\", password=pwd_context.hash(\"test\"))\n dbsession.add(new_user)","def create_db_session(self):\n mysql_conn_str = f\"mysql+pymysql://{self.DB_USER}:{self.DB_PSWD}@{self.DB_HOST}:{self.DB_PORT}/{self.DB_NAME}\"\n engine = create_engine(mysql_conn_str)\n Base.metadata.bind = engine\n DBSession = sessionmaker(bind=engine)\n session = DBSession()\n self.create_tables(engine)\n return session","def create_db_session(self, engine):\r\n dbsession = sessionmaker(bind=engine)\r\n session = dbsession()\r\n return session","def pytest_sessionstart(session):\n\n db = Database()\n for a in range(1, 4):\n data = {\n 'author': f'test-author-{a}',\n 'text': f'test-text-{a}'\n }\n phrase = PhraseInput(**data)\n db.add(phrase)\n print('created:')\n print(list(db.items.keys()))","def testapp():\n from webtest import TestApp\n from learning_journal import main\n\n app = main({}, **{'sqlalchemy.url': 'postgres:///amosboldor'})\n testapp = TestApp(app)\n\n session_factory = app.registry[\"dbsession_factory\"]\n engine = session_factory().bind\n Base.metadata.drop_all(bind=engine)\n Base.metadata.create_all(bind=engine)\n\n return testapp","def create_session(uri: str = os.environ.get(\"OBSERVATORY_DB_URI\"), connect_args=None, poolclass=None):\n\n if uri is None:\n raise ValueError(\n \"observatory.api.orm.create_session: please set the create_session `uri` parameter \"\n \"or the environment variable OBSERVATORY_DB_URI with a valid PostgreSQL workflow string\"\n )\n\n if connect_args is None:\n connect_args = dict()\n\n engine = create_engine(uri, convert_unicode=True, connect_args=connect_args, poolclass=poolclass)\n s = scoped_session(sessionmaker(autocommit=False, autoflush=False, bind=engine))\n Base.query = s.query_property()\n Base.metadata.create_all(bind=engine) # create all tables.\n\n return s","def create_test_db(force_prompt=False):\n _create_database(is_prompt_forced=bool(force_prompt))","def testing_get_db() -> Generator:\n db = TestSessionLocal()\n try:\n yield db\n finally:\n db.close()","def test_database_sessions(web_app):\n db = DB(connect_url=TEST_URL, web_app=web_app, echo=web_app)\n db.init()\n with db.session() as session:\n archive = Archive(archive_id='0000', name='test')\n session.add(archive)\n with pytest.raises(IntegrityError):\n with db.session() as session:\n archive = Archive(archive_id='0000', name='test')\n session.add(archive)\n with pytest.raises(ValueError):\n with db.session() as session:\n archive = Archive(archive_id='0001', name='test')\n session.add(archive)\n raise ValueError('test')\n db.close()","def test_create_database(self):\n self.assertTrue(self.ss.create_database(self.test_database),\n \"Create testing database\")\n self.assertTrue(os.path.exists(self.test_database))\n self.assertNotEqual(self.test_database, self.ss.data_file(),\n \"Should not connect to created database\")","def setUp(self):\n\n self.app = Flask(__name__)\n self.client = self.app.test_client()\n self.app.config['TESTING'] = True\n db = SQLAlchemy()\n\n connect_to_db(self.app, \"postgresql:///testdb\")\n\n subprocess.check_output(\"psql testdb < test_query.sql\", shell=True)\n\n with self.app.test_request_context():\n\n db.create_all()","def setUp(self):\n\n self.app = Flask(__name__)\n self.client = self.app.test_client()\n self.app.config['TESTING'] = True\n db = SQLAlchemy()\n\n connect_to_db(self.app, \"postgresql:///testdb\")\n\n subprocess.check_output(\"psql testdb < test_query.sql\", shell=True)\n\n with self.app.test_request_context():\n\n db.create_all()","def setUp(self):\n\n self.app = Flask(__name__)\n self.client = self.app.test_client()\n self.app.config['TESTING'] = True\n db = SQLAlchemy()\n\n connect_to_db(self.app, \"postgresql:///testdb\")\n\n subprocess.check_output(\"psql testdb < test_query.sql\", shell=True)\n\n with self.app.test_request_context():\n\n db.create_all()","def init_postgres(testing):\n if 'POSTGRESQL_DATABASE_URI' in app.config:\n if not testing:\n # not testing will use request context as scope\n # for sqlalchemy Session object\n from flask import _app_ctx_stack\n import pgsqlutils.base as pgbase\n from pgsqlutils.base import get_db_conf, init_db_conn\n from sqlalchemy.orm import sessionmaker, scoped_session\n dbconf = get_db_conf()\n dbconf.DATABASE_URI = app.config['POSTGRESQL_DATABASE_URI']\n # monkey patching to replace default session\n # by a sessing handled by flask\n pgbase.Session = scoped_session(\n sessionmaker(),\n scopefunc=_app_ctx_stack.__ident_func__)\n init_db_conn()\n else:\n # Testing will use current thread as scope for Session\n from pgsqlutils.base import get_db_conf, init_db_conn\n dbconf = get_db_conf()\n dbconf.DATABASE_URI = app.config['POSTGRESQL_DATABASE_URI']\n init_db_conn()","def sess_file():\n engine = create_engine(\"sqlite:///fire_sim.db\", echo=True)\n Base.metadata.create_all(engine)\n sess = sessionmaker(bind=engine)()\n return sess","def test_user(db_session):\n new_user = User(username=\"test\", password=pwd_context.hash(\"test\"))\n db_session.add(new_user)","async def test_db():\n test_uta_db = UTADatabase()\n await test_uta_db._create_genomic_table()\n return test_uta_db","def init_session(connection_string=None, drop=False):\n if connection_string is None:\n engine = create_engine('sqlite://',\n echo=False,\n connect_args={'check_same_thread':False},\n poolclass=StaticPool)\n else:\n engine = create_engine(connection_string)\n\n from database.model import Base\n\n global session\n\n if drop:\n try:\n old_session = session\n Base.metadata.drop_all(bind=old_session.bind)\n except:\n pass\n\n db_session = scoped_session(sessionmaker(autocommit=False,\n autoflush=False,\n bind=engine))\n Base.metadata.create_all(bind=engine)\n\n session = db_session","def setUp(self):\n\n app.config[\"TESTING\"] = True\n app.config[\"SECRET_KEY\"] = \"ABC\"\n self.client = app.test_client()\n\n # Connect to test database\n connect_to_db(app)\n db.drop_all()\n db.create_all()\n load_test()\n\n # Put user1 into session.\n with self.client as c:\n with c.session_transaction() as sess:\n sess[\"current_user\"] = 1","def test_session_promotion(self):\r\n cursor = self.db.cursor()\r\n cursor.execute(\"INSERT INTO session VALUES ('123456', 0, 0)\")\r\n incookie = Cookie()\r\n incookie['trac_session'] = '123456'\r\n outcookie = Cookie()\r\n req = Mock(authname='john', base_path='/', incookie=incookie,\r\n outcookie=outcookie)\r\n session = Session(self.env, req)\r\n self.assertEqual('john', session.sid)\r\n session.save()\r\n\r\n cursor.execute(\"SELECT sid,authenticated FROM session\")\r\n self.assertEqual(('john', 1), cursor.fetchone())\r\n self.assertEqual(None, cursor.fetchone())","def get_session(db_config):\n psql_config = db_config[\"PSQL\"]\n db_credentials = 'postgresql://{}:{}@{}:{}/{}'.format(\n psql_config[\"USER\"], psql_config[\"PASSWORD\"], psql_config[\"HOST\"], psql_config[\"PORT\"], psql_config[\"DB_NAME\"])\n engine = create_engine(db_credentials)\n Session.configure(bind=engine)\n return Session()","def session(db, request):\n connection = db.engine.connect()\n transaction = connection.begin()\n\n options = dict(bind=connection, binds={})\n session = db.create_scoped_session(options=options)\n\n db.session = session\n\n def teardown():\n transaction.rollback()\n connection.close()\n session.remove()\n\n request.addfinalizer(teardown)\n return session","def setUp(self):\n\n self.app = Flask(__name__)\n self.client = self.app.test_client()\n self.app.config['TESTING'] = True\n\n db = SQLAlchemy()\n connect_to_db(self.app, \"postgresql:///testdb\")\n\n subprocess.check_output(\"psql testdb < test_query.sql\", shell=True)\n\n with self.app.test_request_context():\n\n db.create_all()","def session(db, request):\n connection = db.engine.connect()\n transaction = connection.begin()\n options = dict(bind=connection, binds={})\n session = db.create_scoped_session(options=options)\n db.session = session\n\n def teardown():\n transaction.rollback()\n connection.close()\n session.remove()\n\n request.addfinalizer(teardown)\n return session","def Session(ioname, echo=True):\n from sqlalchemy import create_engine\n from sqlalchemy.orm import sessionmaker\n dbpath = userenv.joinpath('scanbox', ioname, 'db.sqlite3')\n engine = create_engine('sqlite:///{}'.format(dbpath),\n echo=echo, convert_unicode=True)\n return sessionmaker(engine, autocommit=False)","def create_database(request):\n pg_user = TestConfig.DB_OPTS.get(\"username\")\n pg_host = TestConfig.DB_OPTS.get(\"host\")\n pg_port = TestConfig.DB_OPTS.get(\"port\")\n pg_db = TestConfig.DB_OPTS[\"database\"]\n pg_pass = TestConfig.DB_OPTS.get(\"password\")\n janitor = DatabaseJanitor(\n pg_user, pg_host, pg_port, pg_db, TestConfig.POSTGRES_VER, pg_pass\n )\n try:\n janitor.init()\n except DuplicateDatabase:\n janitor.drop()\n janitor.init()\n\n @request.addfinalizer\n def drop_database(): # pylint: disable=unused-variable\n janitor.drop()","def create():\n\tcreate_db()","def __init__(self):\n engine = create_engine(\"postgresql://postgres:1@localhost:5432/postgres\")\n session_class = sessionmaker(bind=engine)\n self.session = session_class()","def setup_db(config):\n # create the URL from the configuration\n db_url = URL(**config)\n db = create_engine(db_url)\n Session = sessionmaker(db)\n # Link the relational model to the database\n Model.metadata.create_all(db)\n\n return db, Session","def dbsession(cls):\n sqlahelper = cls.dbsqlahelper\n return sqlahelper.getmake_session()","def override_get_db():\n try:\n db = TestingSessionLocal()\n yield db\n finally:\n db.close()","def setUp(self):\n tested_app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.db'\n db.init_app(tested_app)\n with tested_app.app_context():\n db.create_all()\n db.session.commit()","def setup(db_file):\n global session\n\n db_conn = \"sqlite:///%s\" % db_file\n logger.info(\"DB Connection: %s\" % db_conn)\n engine = create_engine(db_conn, connect_args={'check_same_thread':False})\n engine.Echo = True\n Base.metadata.create_all(engine)\n\n Session = scoped_session(sessionmaker(bind=engine))\n session = Session()\n print \"DB Connection: %s\" % db_conn","def create_session(self, username, password, hostname, database, port=3306):\n engine = create_engine(\"mysql+mysqlconnector://%s:%s@%s:%s/%s\" %\n (username, password, hostname, port, database))\n if self.session is not None:\n self.session.close()\n Session = sessionmaker(bind=engine, autoflush=False)\n self.session = Session()","def db_session(request, config):\n from h import db\n engine = db.make_engine(config.registry.settings)\n session = db.Session(bind=engine)\n try:\n yield session\n finally:\n session.close()\n engine.dispose()","def create_session():\n app = Application.query.filter_by(id=request.json['app']).first()\n questionnaire = Questionnaire.query.filter_by(id=request.json['questionnaire']).first()\n expected_emotions = request.json['expected_emotions']\n\n # validate application type\n if not app:\n return {'status': 'error', 'message': 'Invalid application.'}, 400\n\n new_session = Session(app=app, expected_emotions=expected_emotions, questionnaire=questionnaire)\n\n db.session.add(new_session)\n db.session.commit()\n\n result = session_schema.dump(new_session).data\n\n return jsonify({'status': 'success', 'message': 'Created new session for application with id of {}.'.format(request.json['app']), 'data': result}), 201","def test_create_session(self):\n finder = FinderInsidePro(self.test_key)\n session_id = finder.create_session(2811)\n assert isinstance(session_id, str)\n assert session_id == finder.session_id\n assert len(session_id)","def create_session(self, **params):\n raise NotImplementedError('Should be implemented by a sub-class.')","def testSessionCreate(self):\n success = False\n project = None\n\n try:\n project = self.session.create_project()\n\n success = True\n except Exception:\n pass\n\n self.failUnless(success)\n self.failIf(project is None)","def testTrackingDbCreation(self):\n trackingdb = db.TrackingDb(database=self.trackingDb)\n self.assertTrue(os.path.isfile(self.trackingDb))\n trackingdb.close()","def testTrackingDbCreation(self):\n trackingdb = db.TrackingDb(database=self.trackingDb)\n self.assertTrue(os.path.isfile(self.trackingDb))\n trackingdb.close()","def create_db():\n init_postgres(current_app.config['SQLALCHEMY_DATABASE_URI'])","def create_test_db(self, verbosity=1, autoclobber=False):\n # Don't import django.core.management if it isn't needed.\n test_database_name = self._get_test_db_name()\n \n if self.connection.settings_dict.get('ENGINE', '').endswith('.sqlite3')\\\n and test_database_name != ':memory:':\n if os.access(test_database_name, os.F_OK):\n print \"sqlite test database found !\"\n \n #self._create_test_db(verbosity, autoclobber)\n \n self.connection.close()\n self.connection.settings_dict[\"NAME\"] = test_database_name\n \n # Confirm the feature set of the test database\n self.connection.features.confirm()\n \n # Get a cursor (even though we don't need one yet). This has\n # the side effect of initializing the test database.\n self.connection.cursor()\n\n return test_database_name","def setUp(self):\n db.create_all()\n user = User(\"eschoppik\", \"secret\", \"Elie S\", \"elie@elie.com\")\n db.session.add(user)\n db.session.commit()","def create_session(self):\n self._session = self.create_scoped_session()\n self.session = self._session()","def create(self):\n dbcase = models.create(models.TestCase, **self._data)\n _dbsession.add(dbcase)\n for key, value in self._many2many.items():\n setattr(dbcase, key, value)\n _dbsession.commit()\n return dbcase","def testConnection() :\n dbConfig = comSettings() \n databaseConnection = dbConfig[\"dbFilePath\"] + '1000001' + '.db'\n db = create_engine(databaseConnection)\n conn = db.connect()\n print(\"Created connection to test database - don't forget to close!\")\n return conn","def create_database():\n create_db(app)","def client(app):\n conn = engine.connect()\n transaction = conn.begin()\n app.db_session = create_session(conn)\n yield app.test_client()\n # No need to retain the junk we\n # put in the DB for testing.\n transaction.rollback()\n conn.close()\n app.db_session.remove()","def _create_db(self):\n self.db = easydms.dbcore.Database(\":memory:\")\n self.db.create_db()","def setUp(self):\n from application.models import User\n api.app.config['SQLALCHEMY_DATABASE_URI'] = \"sqlite://\"\n api.app.config['TESTING'] = True\n self.app = api.app.test_client()\n db.create_all()\n self.user = User(username=\"logintester\", password=\"password\")\n db.session.add(self.user)\n db.session.commit()","def create_db():\n from sqlalchemy_utils import database_exists, create_database, drop_database\n if not database_exists(DB_URL):\n print('Creating database.')\n create_database(DB_URL)\n else:\n drop_database(DB_URL)\n create_database(DB_URL)\n print(\"Deleted and created new database\")\n create_tables()","def make_test_object(self):\n return self.orm_cls.testing_create()","def setUp(self):\n\n # Get the Flask test client.\n self.client = app.test_client()\n app.config[\"TESTING\"] = True\n app.config[\"SECRET_KEY\"] = \"key\"\n app.config[\"SQLALCHEMY_TRACK_MODIFICATIONS\"] = False\n\n with self.client as c:\n with c.session_transaction() as sess:\n sess[\"patient_id\"] = 1\n\n # Connect to the test database.\n connect_to_db(app, db_uri=\"postgresql:///testnourish\") \n\n # Create the tables and add the sample data.\n db.create_all()\n load_test_data()","def init_database(self):\n engine = create_engine('sqlite:///todo.db?check_same_thread=False')\n self.Base.metadata.create_all(engine)\n self.session = sessionmaker(bind=engine)()","def make_session(uri=None, echo=None, session_kwargs=None, **kwargs):\n if session_kwargs is None:\n session_kwargs = {}\n engine = create_engine(uri, echo=echo, **kwargs)\n log.debug(\"Created engine for session context\")\n return sqlalchemy.create_session(bind_to=engine, **session_kwargs)","def setUp(self):\n\n # Get the Flask test client\n self.client = app.test_client()\n\n # Show Flask errors that happen during tests\n app.config['TESTING'] = True\n\n #To test sessions we need to set Secret key \n app.config['SECRET_KEY'] = 'key'\n\n # Connect to test database\n connect_to_db(app, \"postgresql:///testdb\")\n\n # Create tables and add sample data\n db.create_all()\n users()\n reviews()\n\n with self.client as c:\n with c.session_transaction() as sess:\n sess['user_id'] = 1","def setup_db():\n engine = create_engine(settings.DATABASE)\n ModelBase.metadata.bind = engine\n ModelBase.metadata.create_all(engine)\n\n return scoped_session(sessionmaker(bind=engine))","def generate_database_object(**kwargs):\n return app.database.Database(\"test.db\", **kwargs)","def main():\n settings = {}\n settings['sqlalchemy.url'] = os.environ['DATABASE_URL']\n config = Configurator(settings=settings)\n config.include('TechLurker.models')\n SessionFactory = config.registry[\"dbsession_factory\"]\n session = SessionFactory()\n return session","def do_Test(testinstance):\n name = mangle_test_name(testinstance.test_name)\n try:\n dbcase = _dbsession.query(models.TestCase).filter(models.TestCase.name==name).one()\n except models.NoResultFound:\n dbcase = create_TestCase(testinstance)\n else:\n if _FORCE:\n _dbsession.delete(dbcase)\n _dbsession.commit()\n dbcase = create_TestCase(testinstance)\n else:\n update_TestCase(testinstance, dbcase)\n return dbcase","def setUp(self):\n\n app.config[\"TESTING\"] = True\n app.config[\"SECRET_KEY\"] = 'oh-so-secret-key'\n self.client = app.test_client()\n\n # Connnect to test db\n connect_to_db(app, \"postgresql:///testdb\")\n\n # Create tables and sample data\n db.create_all()\n example_data()\n\n with self.client as c:\n with c.session_transaction() as sess:\n sess[\"user_id\"] = \"kels\"\n sess[\"spotify_id\"] = \"kelspot\"","def connect_to_database():\n engine = create_engine('postgresql://catalog:password@localhost/catalog')\n Base.metadata.bind = engine\n db_session = sessionmaker(bind=engine)\n session = db_session()\n return session","def create_db():\n db.create_all()\n print ('Intialized....!')","def test_db(app: flask.Flask) -> flask_sqlalchemy.SQLAlchemy:\n db.app = app\n with app.app_context():\n db.create_all()\n\n yield db\n db.session.close()\n db.drop_all()","def init_database(cls):\n conn = config.db_connection_string(Settings)\n cls.Engine = create_engine(conn, echo=Settings.get('DEBUG'))\n cls.Session = sessionmaker(bind=cls.Engine)\n return cls","def create_db():\n db.create_all()\n print(\"DB Created\")","def test_db(app):\n assert app.config['DATABASE'] == 'sqlite:///:memory:'","def connect_db():\n engine = create_engine('sqlite:///app.db', echo=True)\n Base.metadata.bind = engine\n DBSession = sessionmaker(bind=engine)\n session = DBSession()\n return session","def setUp(self):\n self.app = create_app(config_name=\"testing\")\n self.app.config.update(SQLALCHEMY_DATABASE_URI='postgresql+psycopg2://postgres:@localhost:5432/postgres')\n self.app_context = self.app.app_context()\n self.app_context.push()\n # initialize the test client\n self.client = self.app.test_client\n # This is the user test json data with a predefined email and password\n\n with self.app.app_context():\n # create all tables\n db.session.close()\n db.drop_all()\n db.create_all()","def init_new_db(args):\n Base.metadata.drop_all(engine)\n Base.metadata.create_all(engine)\n session = Session()\n session.add(Environment(name='normal', slickurl='http://slicker.homestead-corp.com/slickij', buildurl='?', filename='hs-tcrunij.tar.gz', tcrunijsubdir='hs-tcrunij/tcrunij'))\n session.add(Environment(name='dev', slickurl='http://octomom.homestead-corp.com/slickij', buildurl='?', filename='tcrunij.tar.gz', tcrunijsubdir='tcrunij/tcrunij'))\n session.commit()","def db():\n the_db.session.close()\n the_db.drop_all()\n the_db.create_all()\n return the_db"],"string":"[\n \"def _initTestingDB(): \\n from sqlalchemy import create_engine\\n engine = create_engine('sqlite://')\\n from .models import (\\n Base,\\n TodoUser,\\n )\\n DBSession.configure(bind=engine)\\n Base.metadata.create_all(engine)\\n \\n return DBSession\",\n \"def create_test_db(self, *args, **kw):\\n self.destroy_test_db()\\n self.connection.use_test_datastore = True\\n self.connection.flush()\",\n \"def create_new_test_session(name):\\n now=datetime.datetime.now()\\n is_over=0\\n sql=\\\"INSERT INTO sessions(update_time,is_over,name,total_coverage) VALUES(?,?,?,?)\\\"\\n execute_query(sql,(now,is_over,name,\\\"0\\\"))\\n active_session=get_active_test_session()\\n active_files=get_active_files()\\n for f in active_files:\\n sql=\\\"INSERT INTO sessions_files VALUES(?,?)\\\"\\n execute_query(sql,(active_session[0],f[0]))\",\n \"def create_new_session():\\n database_engine = create_engine(SQLITE_FILE)\\n DeclarativeBase.metadata.create_all(database_engine)\\n DeclarativeBase.bind = database_engine\\n\\n session = sessionmaker()\\n session.configure(bind=database_engine)\\n\\n return session()\",\n \"def make_new_session():\\n session = Session.objects.create(uuid=str(uuid4()), container_id=None)\\n return session.id\",\n \"def test_create_session(self):\\n study_id = self.storage.create_study(sample_study_spec())\\n\\n session = sample_session(study_id=study_id)\\n self.storage.create_session(session)\\n\\n self.assertEqual(self.storage.get_session(study_id, session.id), session)\",\n \"def set_db_session():\\n g.s = database.db_session()\",\n \"def create_db_session():\\n engine = engine = create_engine('sqlite:///budget.db')\\n Base.metadata.bind = engine\\n DBSession = sessionmaker(bind=engine)\\n session = DBSession()\\n return session\",\n \"def db_session(configuration, request):\\n SessionFactory = configuration.registry[\\\"dbsession_factory\\\"]\\n session = SessionFactory()\\n engine = session.bind\\n Base.metadata.create_all(engine)\\n\\n def teardown():\\n session.transaction.rollback()\\n Base.metadata.drop_all(engine)\\n\\n request.addfinalizer(teardown)\\n return session\",\n \"def test_new_session_promotion(self):\\r\\n cursor = self.db.cursor()\\r\\n incookie = Cookie()\\r\\n incookie['trac_session'] = '123456'\\r\\n outcookie = Cookie()\\r\\n req = Mock(authname='john', base_path='/', incookie=incookie,\\r\\n outcookie=outcookie)\\r\\n session = Session(self.env, req)\\r\\n self.assertEqual('john', session.sid)\\r\\n session.save()\\r\\n\\r\\n cursor.execute(\\\"SELECT sid,authenticated FROM session\\\")\\r\\n self.assertEqual(('john', 1), cursor.fetchone())\\r\\n self.assertEqual(None, cursor.fetchone())\",\n \"def start_session(db_path):\\n engine = create_engine('sqlite:///' + db_path)\\n Session = sessionmaker(bind=engine)\\n return Session()\",\n \"def create_session():\\n session = Session()\\n try:\\n yield session\\n session.commit()\\n except:\\n session.rollback()\\n raise\\n finally:\\n session.close()\",\n \"def prepare_database(config):\\n global Session\\n engine = sqlalchemy.create_engine(config.db_string)\\n session_factory = sqlalchemy.orm.sessionmaker(bind=engine)\\n Session = sqlalchemy.orm.scoped_session(session_factory)\",\n \"def db_session(configuration, request):\\n SessionFactory = configuration.registry['dbsession_factory']\\n session = SessionFactory()\\n engine = session.bind\\n Base.metadata.create_all(engine)\\n\\n def teardown():\\n session.transaction.rollback()\\n Entries.__table__.drop(engine)\\n\\n request.addfinalizer(teardown)\\n return session\",\n \"def sess():\\n engine = create_engine(\\\"sqlite://\\\", echo=True)\\n with engine.begin() as conn:\\n conn.execute(\\\"ATTACH DATABASE ':memory:' AS placebo\\\")\\n Base.metadata.create_all(engine)\\n sess = sessionmaker(bind=engine)()\\n return sess\",\n \"def session(request):\\n session = get_test_db_session()\\n request.cls.session = session\\n return session\",\n \"def get_or_create_session(db):\",\n \"def _create_db_session(self):\\r\\n session = Session()\\r\\n try:\\r\\n yield session\\r\\n session.commit()\\r\\n except Exception:\\r\\n session.rollback()\\r\\n raise\\r\\n finally:\\r\\n session.close()\",\n \"def db_session(configuration, request):\\n session_factory = configuration.registry['dbsession_factory']\\n session = session_factory()\\n engine = session.bind\\n Base.metadata.drop_all(engine)\\n Base.metadata.create_all(engine)\\n\\n def teardown():\\n session.transaction.rollback()\\n\\n request.addfinalizer(teardown)\\n return session\",\n \"def create_test_database(cls):\\n from sqlalchemy import engine_from_config\\n from tests.models import Base\\n\\n cls = AppTestCase # set class variables on superclass\\n cls.settings = cls._read_pyramid_settings()\\n cls.engine = engine_from_config(cls.settings, prefix=\\\"sqlalchemy.\\\")\\n print(\\\"Creating the tables on the test database:\\\\n%s\\\" % cls.engine)\\n Base.metadata.drop_all(cls.engine)\\n Base.metadata.create_all(cls.engine)\",\n \"def setUp(self):\\n\\n self.client = server.app.test_client()\\n server.app.config['TESTING'] = True\\n server.app.config['SECRET_KEY'] = \\\"123\\\"\\n\\n # Connect to test database\\n model.connect_to_db(server.app, \\\"postgresql:///testdb\\\")\\n\\n # Create tables and add sample data\\n model.db.create_all()\\n # example_data()\\n\\n with self.client as c:\\n with c.session_transaction() as session:\\n session['user_id'] = 33\\n session['username'] = 'balloonicorn'\\n session['name'] = 'balloonicorn'\",\n \"def database_session():\\n if \\\"CI\\\" in os.environ:\\n con = psycopg2.connect(\\n host=os.environ[\\\"POSTGRES_HOST\\\"],\\n port=os.environ[\\\"POSTGRES_PORT\\\"],\\n user=os.environ[\\\"PGUSER\\\"],\\n password=os.environ[\\\"PGPASSWORD\\\"],\\n )\\n else:\\n con = psycopg2.connect(host=\\\"127.0.0.1\\\", port=\\\"5432\\\")\\n # Setup\\n con.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)\\n cursor = con.cursor()\\n cursor.execute(f'create database \\\"{DB}\\\";')\\n session = Meta.init(CONN_STRING).Session()\\n yield session\\n\\n # Teardown\\n engine = session.get_bind()\\n session.close()\\n engine.dispose()\\n Meta.engine = None\\n\\n cursor.execute(f'drop database \\\"{DB}\\\";')\\n cursor.close()\\n con.close()\",\n \"def test_new_session(self):\\r\\n cookie = Cookie()\\r\\n req = Mock(incookie=Cookie(), outcookie=cookie, authname='anonymous',\\r\\n base_path='/')\\r\\n session = Session(self.env, req)\\r\\n self.assertEqual(session.sid, cookie['trac_session'].value)\\r\\n cursor = self.db.cursor()\\r\\n cursor.execute(\\\"SELECT COUNT(*) FROM session\\\")\\r\\n self.assertEqual(0, cursor.fetchone()[0])\",\n \"def test_get_db_session(initialized_db_url):\\n with utils.get_db_session(initialized_db_url) as db:\\n assert isinstance(db, Session)\",\n \"def setUp(self):\\n\\n self.client = server.app.test_client()\\n server.app.config['TESTING'] = True\\n server.app.config['SECRET_KEY'] = \\\"123\\\"\\n\\n # Connect to test database\\n model.connect_to_db(server.app, \\\"postgresql:///testdb\\\")\\n\\n # Create tables and add sample data\\n model.db.create_all()\\n # example_data()\\n\\n with self.client as c:\\n with c.session_transaction() as session:\\n session['user_id'] = 1\\n session['username'] = 'j'\\n session['name'] = 'l'\\n session['cal_id'] = 1\",\n \"def database_session_wide(app) -> SQLAlchemy:\\n if os.path.exists(get_test_database_path()):\\n os.unlink(get_test_database_path())\\n\\n from pipwatch_api.datastore.models import DATABASE\\n DATABASE.init_app(app=app)\\n DATABASE.create_all()\\n yield DATABASE\\n\\n DATABASE.drop_all()\\n DATABASE.session.close()\\n\\n os.unlink(get_test_database_path())\",\n \"def db_session(configuration, request):\\n SessionFactory = configuration.registry['dbsession_factory']\\n session = SessionFactory()\\n engine = session.bind\\n Base.metadata.drop_all(engine)\\n Base.metadata.create_all(engine)\\n\\n def teardown():\\n session.transaction.rollback()\\n Base.metadata.drop_all(engine)\\n\\n request.addfinalizer(teardown)\\n return session\",\n \"def test_set_session():\",\n \"def setup_session():\\n print(\\\"Setting up session\\\")\\n engine = setup_engine()\\n Base.metadata.bin = engine\\n\\n DBSession = sessionmaker(bind=engine)\\n session = DBSession()\\n\\n return session\",\n \"def new_user(testapp):\\n SessionFactory = testapp.app.registry[\\\"dbsession_factory\\\"]\\n with transaction.manager:\\n dbsession = get_tm_session(SessionFactory, transaction.manager)\\n new_user = User(username=\\\"test\\\", password=pwd_context.hash(\\\"test\\\"))\\n dbsession.add(new_user)\",\n \"def create_db_session(self):\\n mysql_conn_str = f\\\"mysql+pymysql://{self.DB_USER}:{self.DB_PSWD}@{self.DB_HOST}:{self.DB_PORT}/{self.DB_NAME}\\\"\\n engine = create_engine(mysql_conn_str)\\n Base.metadata.bind = engine\\n DBSession = sessionmaker(bind=engine)\\n session = DBSession()\\n self.create_tables(engine)\\n return session\",\n \"def create_db_session(self, engine):\\r\\n dbsession = sessionmaker(bind=engine)\\r\\n session = dbsession()\\r\\n return session\",\n \"def pytest_sessionstart(session):\\n\\n db = Database()\\n for a in range(1, 4):\\n data = {\\n 'author': f'test-author-{a}',\\n 'text': f'test-text-{a}'\\n }\\n phrase = PhraseInput(**data)\\n db.add(phrase)\\n print('created:')\\n print(list(db.items.keys()))\",\n \"def testapp():\\n from webtest import TestApp\\n from learning_journal import main\\n\\n app = main({}, **{'sqlalchemy.url': 'postgres:///amosboldor'})\\n testapp = TestApp(app)\\n\\n session_factory = app.registry[\\\"dbsession_factory\\\"]\\n engine = session_factory().bind\\n Base.metadata.drop_all(bind=engine)\\n Base.metadata.create_all(bind=engine)\\n\\n return testapp\",\n \"def create_session(uri: str = os.environ.get(\\\"OBSERVATORY_DB_URI\\\"), connect_args=None, poolclass=None):\\n\\n if uri is None:\\n raise ValueError(\\n \\\"observatory.api.orm.create_session: please set the create_session `uri` parameter \\\"\\n \\\"or the environment variable OBSERVATORY_DB_URI with a valid PostgreSQL workflow string\\\"\\n )\\n\\n if connect_args is None:\\n connect_args = dict()\\n\\n engine = create_engine(uri, convert_unicode=True, connect_args=connect_args, poolclass=poolclass)\\n s = scoped_session(sessionmaker(autocommit=False, autoflush=False, bind=engine))\\n Base.query = s.query_property()\\n Base.metadata.create_all(bind=engine) # create all tables.\\n\\n return s\",\n \"def create_test_db(force_prompt=False):\\n _create_database(is_prompt_forced=bool(force_prompt))\",\n \"def testing_get_db() -> Generator:\\n db = TestSessionLocal()\\n try:\\n yield db\\n finally:\\n db.close()\",\n \"def test_database_sessions(web_app):\\n db = DB(connect_url=TEST_URL, web_app=web_app, echo=web_app)\\n db.init()\\n with db.session() as session:\\n archive = Archive(archive_id='0000', name='test')\\n session.add(archive)\\n with pytest.raises(IntegrityError):\\n with db.session() as session:\\n archive = Archive(archive_id='0000', name='test')\\n session.add(archive)\\n with pytest.raises(ValueError):\\n with db.session() as session:\\n archive = Archive(archive_id='0001', name='test')\\n session.add(archive)\\n raise ValueError('test')\\n db.close()\",\n \"def test_create_database(self):\\n self.assertTrue(self.ss.create_database(self.test_database),\\n \\\"Create testing database\\\")\\n self.assertTrue(os.path.exists(self.test_database))\\n self.assertNotEqual(self.test_database, self.ss.data_file(),\\n \\\"Should not connect to created database\\\")\",\n \"def setUp(self):\\n\\n self.app = Flask(__name__)\\n self.client = self.app.test_client()\\n self.app.config['TESTING'] = True\\n db = SQLAlchemy()\\n\\n connect_to_db(self.app, \\\"postgresql:///testdb\\\")\\n\\n subprocess.check_output(\\\"psql testdb < test_query.sql\\\", shell=True)\\n\\n with self.app.test_request_context():\\n\\n db.create_all()\",\n \"def setUp(self):\\n\\n self.app = Flask(__name__)\\n self.client = self.app.test_client()\\n self.app.config['TESTING'] = True\\n db = SQLAlchemy()\\n\\n connect_to_db(self.app, \\\"postgresql:///testdb\\\")\\n\\n subprocess.check_output(\\\"psql testdb < test_query.sql\\\", shell=True)\\n\\n with self.app.test_request_context():\\n\\n db.create_all()\",\n \"def setUp(self):\\n\\n self.app = Flask(__name__)\\n self.client = self.app.test_client()\\n self.app.config['TESTING'] = True\\n db = SQLAlchemy()\\n\\n connect_to_db(self.app, \\\"postgresql:///testdb\\\")\\n\\n subprocess.check_output(\\\"psql testdb < test_query.sql\\\", shell=True)\\n\\n with self.app.test_request_context():\\n\\n db.create_all()\",\n \"def init_postgres(testing):\\n if 'POSTGRESQL_DATABASE_URI' in app.config:\\n if not testing:\\n # not testing will use request context as scope\\n # for sqlalchemy Session object\\n from flask import _app_ctx_stack\\n import pgsqlutils.base as pgbase\\n from pgsqlutils.base import get_db_conf, init_db_conn\\n from sqlalchemy.orm import sessionmaker, scoped_session\\n dbconf = get_db_conf()\\n dbconf.DATABASE_URI = app.config['POSTGRESQL_DATABASE_URI']\\n # monkey patching to replace default session\\n # by a sessing handled by flask\\n pgbase.Session = scoped_session(\\n sessionmaker(),\\n scopefunc=_app_ctx_stack.__ident_func__)\\n init_db_conn()\\n else:\\n # Testing will use current thread as scope for Session\\n from pgsqlutils.base import get_db_conf, init_db_conn\\n dbconf = get_db_conf()\\n dbconf.DATABASE_URI = app.config['POSTGRESQL_DATABASE_URI']\\n init_db_conn()\",\n \"def sess_file():\\n engine = create_engine(\\\"sqlite:///fire_sim.db\\\", echo=True)\\n Base.metadata.create_all(engine)\\n sess = sessionmaker(bind=engine)()\\n return sess\",\n \"def test_user(db_session):\\n new_user = User(username=\\\"test\\\", password=pwd_context.hash(\\\"test\\\"))\\n db_session.add(new_user)\",\n \"async def test_db():\\n test_uta_db = UTADatabase()\\n await test_uta_db._create_genomic_table()\\n return test_uta_db\",\n \"def init_session(connection_string=None, drop=False):\\n if connection_string is None:\\n engine = create_engine('sqlite://',\\n echo=False,\\n connect_args={'check_same_thread':False},\\n poolclass=StaticPool)\\n else:\\n engine = create_engine(connection_string)\\n\\n from database.model import Base\\n\\n global session\\n\\n if drop:\\n try:\\n old_session = session\\n Base.metadata.drop_all(bind=old_session.bind)\\n except:\\n pass\\n\\n db_session = scoped_session(sessionmaker(autocommit=False,\\n autoflush=False,\\n bind=engine))\\n Base.metadata.create_all(bind=engine)\\n\\n session = db_session\",\n \"def setUp(self):\\n\\n app.config[\\\"TESTING\\\"] = True\\n app.config[\\\"SECRET_KEY\\\"] = \\\"ABC\\\"\\n self.client = app.test_client()\\n\\n # Connect to test database\\n connect_to_db(app)\\n db.drop_all()\\n db.create_all()\\n load_test()\\n\\n # Put user1 into session.\\n with self.client as c:\\n with c.session_transaction() as sess:\\n sess[\\\"current_user\\\"] = 1\",\n \"def test_session_promotion(self):\\r\\n cursor = self.db.cursor()\\r\\n cursor.execute(\\\"INSERT INTO session VALUES ('123456', 0, 0)\\\")\\r\\n incookie = Cookie()\\r\\n incookie['trac_session'] = '123456'\\r\\n outcookie = Cookie()\\r\\n req = Mock(authname='john', base_path='/', incookie=incookie,\\r\\n outcookie=outcookie)\\r\\n session = Session(self.env, req)\\r\\n self.assertEqual('john', session.sid)\\r\\n session.save()\\r\\n\\r\\n cursor.execute(\\\"SELECT sid,authenticated FROM session\\\")\\r\\n self.assertEqual(('john', 1), cursor.fetchone())\\r\\n self.assertEqual(None, cursor.fetchone())\",\n \"def get_session(db_config):\\n psql_config = db_config[\\\"PSQL\\\"]\\n db_credentials = 'postgresql://{}:{}@{}:{}/{}'.format(\\n psql_config[\\\"USER\\\"], psql_config[\\\"PASSWORD\\\"], psql_config[\\\"HOST\\\"], psql_config[\\\"PORT\\\"], psql_config[\\\"DB_NAME\\\"])\\n engine = create_engine(db_credentials)\\n Session.configure(bind=engine)\\n return Session()\",\n \"def session(db, request):\\n connection = db.engine.connect()\\n transaction = connection.begin()\\n\\n options = dict(bind=connection, binds={})\\n session = db.create_scoped_session(options=options)\\n\\n db.session = session\\n\\n def teardown():\\n transaction.rollback()\\n connection.close()\\n session.remove()\\n\\n request.addfinalizer(teardown)\\n return session\",\n \"def setUp(self):\\n\\n self.app = Flask(__name__)\\n self.client = self.app.test_client()\\n self.app.config['TESTING'] = True\\n\\n db = SQLAlchemy()\\n connect_to_db(self.app, \\\"postgresql:///testdb\\\")\\n\\n subprocess.check_output(\\\"psql testdb < test_query.sql\\\", shell=True)\\n\\n with self.app.test_request_context():\\n\\n db.create_all()\",\n \"def session(db, request):\\n connection = db.engine.connect()\\n transaction = connection.begin()\\n options = dict(bind=connection, binds={})\\n session = db.create_scoped_session(options=options)\\n db.session = session\\n\\n def teardown():\\n transaction.rollback()\\n connection.close()\\n session.remove()\\n\\n request.addfinalizer(teardown)\\n return session\",\n \"def Session(ioname, echo=True):\\n from sqlalchemy import create_engine\\n from sqlalchemy.orm import sessionmaker\\n dbpath = userenv.joinpath('scanbox', ioname, 'db.sqlite3')\\n engine = create_engine('sqlite:///{}'.format(dbpath),\\n echo=echo, convert_unicode=True)\\n return sessionmaker(engine, autocommit=False)\",\n \"def create_database(request):\\n pg_user = TestConfig.DB_OPTS.get(\\\"username\\\")\\n pg_host = TestConfig.DB_OPTS.get(\\\"host\\\")\\n pg_port = TestConfig.DB_OPTS.get(\\\"port\\\")\\n pg_db = TestConfig.DB_OPTS[\\\"database\\\"]\\n pg_pass = TestConfig.DB_OPTS.get(\\\"password\\\")\\n janitor = DatabaseJanitor(\\n pg_user, pg_host, pg_port, pg_db, TestConfig.POSTGRES_VER, pg_pass\\n )\\n try:\\n janitor.init()\\n except DuplicateDatabase:\\n janitor.drop()\\n janitor.init()\\n\\n @request.addfinalizer\\n def drop_database(): # pylint: disable=unused-variable\\n janitor.drop()\",\n \"def create():\\n\\tcreate_db()\",\n \"def __init__(self):\\n engine = create_engine(\\\"postgresql://postgres:1@localhost:5432/postgres\\\")\\n session_class = sessionmaker(bind=engine)\\n self.session = session_class()\",\n \"def setup_db(config):\\n # create the URL from the configuration\\n db_url = URL(**config)\\n db = create_engine(db_url)\\n Session = sessionmaker(db)\\n # Link the relational model to the database\\n Model.metadata.create_all(db)\\n\\n return db, Session\",\n \"def dbsession(cls):\\n sqlahelper = cls.dbsqlahelper\\n return sqlahelper.getmake_session()\",\n \"def override_get_db():\\n try:\\n db = TestingSessionLocal()\\n yield db\\n finally:\\n db.close()\",\n \"def setUp(self):\\n tested_app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.db'\\n db.init_app(tested_app)\\n with tested_app.app_context():\\n db.create_all()\\n db.session.commit()\",\n \"def setup(db_file):\\n global session\\n\\n db_conn = \\\"sqlite:///%s\\\" % db_file\\n logger.info(\\\"DB Connection: %s\\\" % db_conn)\\n engine = create_engine(db_conn, connect_args={'check_same_thread':False})\\n engine.Echo = True\\n Base.metadata.create_all(engine)\\n\\n Session = scoped_session(sessionmaker(bind=engine))\\n session = Session()\\n print \\\"DB Connection: %s\\\" % db_conn\",\n \"def create_session(self, username, password, hostname, database, port=3306):\\n engine = create_engine(\\\"mysql+mysqlconnector://%s:%s@%s:%s/%s\\\" %\\n (username, password, hostname, port, database))\\n if self.session is not None:\\n self.session.close()\\n Session = sessionmaker(bind=engine, autoflush=False)\\n self.session = Session()\",\n \"def db_session(request, config):\\n from h import db\\n engine = db.make_engine(config.registry.settings)\\n session = db.Session(bind=engine)\\n try:\\n yield session\\n finally:\\n session.close()\\n engine.dispose()\",\n \"def create_session():\\n app = Application.query.filter_by(id=request.json['app']).first()\\n questionnaire = Questionnaire.query.filter_by(id=request.json['questionnaire']).first()\\n expected_emotions = request.json['expected_emotions']\\n\\n # validate application type\\n if not app:\\n return {'status': 'error', 'message': 'Invalid application.'}, 400\\n\\n new_session = Session(app=app, expected_emotions=expected_emotions, questionnaire=questionnaire)\\n\\n db.session.add(new_session)\\n db.session.commit()\\n\\n result = session_schema.dump(new_session).data\\n\\n return jsonify({'status': 'success', 'message': 'Created new session for application with id of {}.'.format(request.json['app']), 'data': result}), 201\",\n \"def test_create_session(self):\\n finder = FinderInsidePro(self.test_key)\\n session_id = finder.create_session(2811)\\n assert isinstance(session_id, str)\\n assert session_id == finder.session_id\\n assert len(session_id)\",\n \"def create_session(self, **params):\\n raise NotImplementedError('Should be implemented by a sub-class.')\",\n \"def testSessionCreate(self):\\n success = False\\n project = None\\n\\n try:\\n project = self.session.create_project()\\n\\n success = True\\n except Exception:\\n pass\\n\\n self.failUnless(success)\\n self.failIf(project is None)\",\n \"def testTrackingDbCreation(self):\\n trackingdb = db.TrackingDb(database=self.trackingDb)\\n self.assertTrue(os.path.isfile(self.trackingDb))\\n trackingdb.close()\",\n \"def testTrackingDbCreation(self):\\n trackingdb = db.TrackingDb(database=self.trackingDb)\\n self.assertTrue(os.path.isfile(self.trackingDb))\\n trackingdb.close()\",\n \"def create_db():\\n init_postgres(current_app.config['SQLALCHEMY_DATABASE_URI'])\",\n \"def create_test_db(self, verbosity=1, autoclobber=False):\\n # Don't import django.core.management if it isn't needed.\\n test_database_name = self._get_test_db_name()\\n \\n if self.connection.settings_dict.get('ENGINE', '').endswith('.sqlite3')\\\\\\n and test_database_name != ':memory:':\\n if os.access(test_database_name, os.F_OK):\\n print \\\"sqlite test database found !\\\"\\n \\n #self._create_test_db(verbosity, autoclobber)\\n \\n self.connection.close()\\n self.connection.settings_dict[\\\"NAME\\\"] = test_database_name\\n \\n # Confirm the feature set of the test database\\n self.connection.features.confirm()\\n \\n # Get a cursor (even though we don't need one yet). This has\\n # the side effect of initializing the test database.\\n self.connection.cursor()\\n\\n return test_database_name\",\n \"def setUp(self):\\n db.create_all()\\n user = User(\\\"eschoppik\\\", \\\"secret\\\", \\\"Elie S\\\", \\\"elie@elie.com\\\")\\n db.session.add(user)\\n db.session.commit()\",\n \"def create_session(self):\\n self._session = self.create_scoped_session()\\n self.session = self._session()\",\n \"def create(self):\\n dbcase = models.create(models.TestCase, **self._data)\\n _dbsession.add(dbcase)\\n for key, value in self._many2many.items():\\n setattr(dbcase, key, value)\\n _dbsession.commit()\\n return dbcase\",\n \"def testConnection() :\\n dbConfig = comSettings() \\n databaseConnection = dbConfig[\\\"dbFilePath\\\"] + '1000001' + '.db'\\n db = create_engine(databaseConnection)\\n conn = db.connect()\\n print(\\\"Created connection to test database - don't forget to close!\\\")\\n return conn\",\n \"def create_database():\\n create_db(app)\",\n \"def client(app):\\n conn = engine.connect()\\n transaction = conn.begin()\\n app.db_session = create_session(conn)\\n yield app.test_client()\\n # No need to retain the junk we\\n # put in the DB for testing.\\n transaction.rollback()\\n conn.close()\\n app.db_session.remove()\",\n \"def _create_db(self):\\n self.db = easydms.dbcore.Database(\\\":memory:\\\")\\n self.db.create_db()\",\n \"def setUp(self):\\n from application.models import User\\n api.app.config['SQLALCHEMY_DATABASE_URI'] = \\\"sqlite://\\\"\\n api.app.config['TESTING'] = True\\n self.app = api.app.test_client()\\n db.create_all()\\n self.user = User(username=\\\"logintester\\\", password=\\\"password\\\")\\n db.session.add(self.user)\\n db.session.commit()\",\n \"def create_db():\\n from sqlalchemy_utils import database_exists, create_database, drop_database\\n if not database_exists(DB_URL):\\n print('Creating database.')\\n create_database(DB_URL)\\n else:\\n drop_database(DB_URL)\\n create_database(DB_URL)\\n print(\\\"Deleted and created new database\\\")\\n create_tables()\",\n \"def make_test_object(self):\\n return self.orm_cls.testing_create()\",\n \"def setUp(self):\\n\\n # Get the Flask test client.\\n self.client = app.test_client()\\n app.config[\\\"TESTING\\\"] = True\\n app.config[\\\"SECRET_KEY\\\"] = \\\"key\\\"\\n app.config[\\\"SQLALCHEMY_TRACK_MODIFICATIONS\\\"] = False\\n\\n with self.client as c:\\n with c.session_transaction() as sess:\\n sess[\\\"patient_id\\\"] = 1\\n\\n # Connect to the test database.\\n connect_to_db(app, db_uri=\\\"postgresql:///testnourish\\\") \\n\\n # Create the tables and add the sample data.\\n db.create_all()\\n load_test_data()\",\n \"def init_database(self):\\n engine = create_engine('sqlite:///todo.db?check_same_thread=False')\\n self.Base.metadata.create_all(engine)\\n self.session = sessionmaker(bind=engine)()\",\n \"def make_session(uri=None, echo=None, session_kwargs=None, **kwargs):\\n if session_kwargs is None:\\n session_kwargs = {}\\n engine = create_engine(uri, echo=echo, **kwargs)\\n log.debug(\\\"Created engine for session context\\\")\\n return sqlalchemy.create_session(bind_to=engine, **session_kwargs)\",\n \"def setUp(self):\\n\\n # Get the Flask test client\\n self.client = app.test_client()\\n\\n # Show Flask errors that happen during tests\\n app.config['TESTING'] = True\\n\\n #To test sessions we need to set Secret key \\n app.config['SECRET_KEY'] = 'key'\\n\\n # Connect to test database\\n connect_to_db(app, \\\"postgresql:///testdb\\\")\\n\\n # Create tables and add sample data\\n db.create_all()\\n users()\\n reviews()\\n\\n with self.client as c:\\n with c.session_transaction() as sess:\\n sess['user_id'] = 1\",\n \"def setup_db():\\n engine = create_engine(settings.DATABASE)\\n ModelBase.metadata.bind = engine\\n ModelBase.metadata.create_all(engine)\\n\\n return scoped_session(sessionmaker(bind=engine))\",\n \"def generate_database_object(**kwargs):\\n return app.database.Database(\\\"test.db\\\", **kwargs)\",\n \"def main():\\n settings = {}\\n settings['sqlalchemy.url'] = os.environ['DATABASE_URL']\\n config = Configurator(settings=settings)\\n config.include('TechLurker.models')\\n SessionFactory = config.registry[\\\"dbsession_factory\\\"]\\n session = SessionFactory()\\n return session\",\n \"def do_Test(testinstance):\\n name = mangle_test_name(testinstance.test_name)\\n try:\\n dbcase = _dbsession.query(models.TestCase).filter(models.TestCase.name==name).one()\\n except models.NoResultFound:\\n dbcase = create_TestCase(testinstance)\\n else:\\n if _FORCE:\\n _dbsession.delete(dbcase)\\n _dbsession.commit()\\n dbcase = create_TestCase(testinstance)\\n else:\\n update_TestCase(testinstance, dbcase)\\n return dbcase\",\n \"def setUp(self):\\n\\n app.config[\\\"TESTING\\\"] = True\\n app.config[\\\"SECRET_KEY\\\"] = 'oh-so-secret-key'\\n self.client = app.test_client()\\n\\n # Connnect to test db\\n connect_to_db(app, \\\"postgresql:///testdb\\\")\\n\\n # Create tables and sample data\\n db.create_all()\\n example_data()\\n\\n with self.client as c:\\n with c.session_transaction() as sess:\\n sess[\\\"user_id\\\"] = \\\"kels\\\"\\n sess[\\\"spotify_id\\\"] = \\\"kelspot\\\"\",\n \"def connect_to_database():\\n engine = create_engine('postgresql://catalog:password@localhost/catalog')\\n Base.metadata.bind = engine\\n db_session = sessionmaker(bind=engine)\\n session = db_session()\\n return session\",\n \"def create_db():\\n db.create_all()\\n print ('Intialized....!')\",\n \"def test_db(app: flask.Flask) -> flask_sqlalchemy.SQLAlchemy:\\n db.app = app\\n with app.app_context():\\n db.create_all()\\n\\n yield db\\n db.session.close()\\n db.drop_all()\",\n \"def init_database(cls):\\n conn = config.db_connection_string(Settings)\\n cls.Engine = create_engine(conn, echo=Settings.get('DEBUG'))\\n cls.Session = sessionmaker(bind=cls.Engine)\\n return cls\",\n \"def create_db():\\n db.create_all()\\n print(\\\"DB Created\\\")\",\n \"def test_db(app):\\n assert app.config['DATABASE'] == 'sqlite:///:memory:'\",\n \"def connect_db():\\n engine = create_engine('sqlite:///app.db', echo=True)\\n Base.metadata.bind = engine\\n DBSession = sessionmaker(bind=engine)\\n session = DBSession()\\n return session\",\n \"def setUp(self):\\n self.app = create_app(config_name=\\\"testing\\\")\\n self.app.config.update(SQLALCHEMY_DATABASE_URI='postgresql+psycopg2://postgres:@localhost:5432/postgres')\\n self.app_context = self.app.app_context()\\n self.app_context.push()\\n # initialize the test client\\n self.client = self.app.test_client\\n # This is the user test json data with a predefined email and password\\n\\n with self.app.app_context():\\n # create all tables\\n db.session.close()\\n db.drop_all()\\n db.create_all()\",\n \"def init_new_db(args):\\n Base.metadata.drop_all(engine)\\n Base.metadata.create_all(engine)\\n session = Session()\\n session.add(Environment(name='normal', slickurl='http://slicker.homestead-corp.com/slickij', buildurl='?', filename='hs-tcrunij.tar.gz', tcrunijsubdir='hs-tcrunij/tcrunij'))\\n session.add(Environment(name='dev', slickurl='http://octomom.homestead-corp.com/slickij', buildurl='?', filename='tcrunij.tar.gz', tcrunijsubdir='tcrunij/tcrunij'))\\n session.commit()\",\n \"def db():\\n the_db.session.close()\\n the_db.drop_all()\\n the_db.create_all()\\n return the_db\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7618117","0.73792046","0.7159167","0.71482813","0.7045171","0.7042163","0.69432914","0.690918","0.6870981","0.6835914","0.6805257","0.6765318","0.6759865","0.673872","0.67327875","0.6709266","0.67053777","0.66906506","0.66815907","0.6679495","0.66528684","0.6644084","0.6643189","0.66405797","0.66324407","0.6631173","0.6620157","0.6600464","0.6582669","0.6564808","0.65624565","0.65439403","0.65303427","0.65252423","0.6514289","0.6505989","0.64590025","0.6450526","0.64283425","0.6420565","0.6420565","0.6420565","0.6418084","0.64117616","0.6400536","0.6394444","0.6391641","0.6383951","0.63759196","0.6372248","0.63683164","0.6368107","0.6365458","0.6337103","0.63265634","0.6309905","0.63034993","0.6302421","0.6299355","0.6286034","0.6283781","0.62832373","0.62822866","0.6272534","0.62646854","0.6256675","0.62529916","0.62387705","0.6238678","0.6238678","0.6238486","0.6228233","0.62226456","0.6211714","0.6209416","0.6208081","0.6196998","0.6188959","0.61877674","0.61818224","0.6173746","0.61523753","0.61390626","0.6137124","0.6121883","0.6103505","0.6095695","0.60891044","0.6087866","0.6085828","0.60846794","0.60833573","0.6078786","0.60671073","0.6066129","0.6064917","0.6060465","0.606016","0.6060039","0.60531235","0.6050148"],"string":"[\n \"0.7618117\",\n \"0.73792046\",\n \"0.7159167\",\n \"0.71482813\",\n \"0.7045171\",\n \"0.7042163\",\n \"0.69432914\",\n \"0.690918\",\n \"0.6870981\",\n \"0.6835914\",\n \"0.6805257\",\n \"0.6765318\",\n \"0.6759865\",\n \"0.673872\",\n \"0.67327875\",\n \"0.6709266\",\n \"0.67053777\",\n \"0.66906506\",\n \"0.66815907\",\n \"0.6679495\",\n \"0.66528684\",\n \"0.6644084\",\n \"0.6643189\",\n \"0.66405797\",\n \"0.66324407\",\n \"0.6631173\",\n \"0.6620157\",\n \"0.6600464\",\n \"0.6582669\",\n \"0.6564808\",\n \"0.65624565\",\n \"0.65439403\",\n \"0.65303427\",\n \"0.65252423\",\n \"0.6514289\",\n \"0.6505989\",\n \"0.64590025\",\n \"0.6450526\",\n \"0.64283425\",\n \"0.6420565\",\n \"0.6420565\",\n \"0.6420565\",\n \"0.6418084\",\n \"0.64117616\",\n \"0.6400536\",\n \"0.6394444\",\n \"0.6391641\",\n \"0.6383951\",\n \"0.63759196\",\n \"0.6372248\",\n \"0.63683164\",\n \"0.6368107\",\n \"0.6365458\",\n \"0.6337103\",\n \"0.63265634\",\n \"0.6309905\",\n \"0.63034993\",\n \"0.6302421\",\n \"0.6299355\",\n \"0.6286034\",\n \"0.6283781\",\n \"0.62832373\",\n \"0.62822866\",\n \"0.6272534\",\n \"0.62646854\",\n \"0.6256675\",\n \"0.62529916\",\n \"0.62387705\",\n \"0.6238678\",\n \"0.6238678\",\n \"0.6238486\",\n \"0.6228233\",\n \"0.62226456\",\n \"0.6211714\",\n \"0.6209416\",\n \"0.6208081\",\n \"0.6196998\",\n \"0.6188959\",\n \"0.61877674\",\n \"0.61818224\",\n \"0.6173746\",\n \"0.61523753\",\n \"0.61390626\",\n \"0.6137124\",\n \"0.6121883\",\n \"0.6103505\",\n \"0.6095695\",\n \"0.60891044\",\n \"0.6087866\",\n \"0.6085828\",\n \"0.60846794\",\n \"0.60833573\",\n \"0.6078786\",\n \"0.60671073\",\n \"0.6066129\",\n \"0.6064917\",\n \"0.6060465\",\n \"0.606016\",\n \"0.6060039\",\n \"0.60531235\",\n \"0.6050148\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24585,"cells":{"query":{"kind":"string","value":"Reflect the elements of a numpy array along a specified axis about the first element."},"document":{"kind":"string","value":"def reflect(arr,axis=0,sign=1):\n refl_idx = axis * [slice(None)] + [slice(None,0,-1), Ellipsis]\n return np.concatenate((arr[tuple(refl_idx)],arr), axis=axis)"},"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 reflect_array(x, axis=1, kind='even'):\n if axis == 0:\n x_sym = np.flipud(x)\n elif axis == 1:\n x_sym = np.fliplr(x)\n else:\n raise NotImplementedError\n\n if kind == 'even':\n fact = 1.0\n elif kind == 'odd':\n fact = -1.0\n else:\n raise NotImplementedError\n\n return np.concatenate((fact*x_sym, x), axis=axis)","def _np_apply_along_axis(func1d, axis: int, arr: np.ndarray) -> np.ndarray:\n\n assert arr.ndim == 2\n assert axis in [0, 1]\n\n if axis == 0:\n result = np.empty(arr.shape[1])\n for i in range(len(result)):\n result[i] = func1d(arr[:, i])\n return result\n\n result = np.empty(arr.shape[0])\n for i in range(len(result)):\n result[i] = func1d(arr[i, :])\n\n return result","def __call__(self, array, axis=None):\n raise NotImplementedError()","def steppify(arr, axis='x'):\n\t\n\tif axis == 'x':\n\t\tnewarr = np.r_[arr[0], np.dstack((arr[1:], arr[1:])).flatten()]\n\t\n\telif axis == 'y':\n\t\tnewarr = np.r_[np.dstack((arr[:-1], arr[:-1])).flatten(), arr[-1]]\n\t\n\telse:\n\t\tprint('your axes in steppify are improperly identified')\n\n\treturn newarr","def shuffle_array_along(X, axis=0, inline=True):\n if not inline:\n X = X.copy()\n np.apply_along_axis(np.random.shuffle, axis, X)\n if not inline:\n return X","def one_dim(a: cython.double[:]):\n a[0] *= 2\n return a[0], a.ndim","def nonzero_first(arr, *, axis):\n def nonzero_first_1d(arr):\n try:\n return np.nonzero(arr)[0][0]\n except IndexError:\n return -1\n return np.apply_along_axis(nonzero_first_1d, axis, arr)","def forward_one(self, x):\n return np.squeeze(self.forward(x[np.newaxis,:]), axis=0)","def _asvector(self, arr):\n result = self._moveaxis(arr, [-2, -1], [0, 1])\n return self.domain.element(result)","def real(x):\n return x[..., 0]","def _chk_asarray(a, axis):\r\n if axis is None:\r\n a = ravel(a)\r\n outaxis = 0\r\n else:\r\n a = asarray(a)\r\n outaxis = axis\r\n return a, outaxis","def trans(array,dim):\n return array[filter(lambda x: x != dim,range(len(array)) ) ]","def _swap_axis(input_tensor, dim_index, last_index, name=None):\n return array_ops.transpose(\n input_tensor,\n array_ops.concat([\n math_ops.range(dim_index), [last_index],\n math_ops.range(dim_index + 1, last_index), [dim_index]\n ], 0),\n name=name)","def reflect(self):\n self.vertices[-1, :] = self.reflected","def apply_array(self, array: np.ndarray) -> np.ndarray:\n functions = (\n f for f, b in zip((np.transpose, np.fliplr, np.flipud), astuple(self)) if b\n )\n return reduce(lambda f, g: lambda x: g(f(x)), functions, lambda x: x)(array)","def test_broadcast(self):\n a = np.ones((3, 4, 1))\n ai = np.ones((1, 2, 5), dtype=np.intp)\n actual = take_along_axis(a, ai, axis=1)\n assert_equal(actual.shape, (3, 2, 5))","def indep_roll(arr, shifts, axis=1):\n arr = np.swapaxes(arr, axis, -1)\n all_idcs = np.ogrid[[slice(0, n) for n in arr.shape]]\n\n # Convert to a positive shift\n shifts[shifts < 0] += arr.shape[-1]\n all_idcs[-1] = all_idcs[-1] - shifts[:, np.newaxis]\n\n result = arr[tuple(all_idcs)]\n arr = np.swapaxes(result, -1, axis)\n return arr","def corresponding_ravel(X,axis=0):\n\n t1=np.c_[tuple([di.ravel() for di in X])]\n\n if axis==1:\n t1=t1.T\n\n return t1","def xray(im, axis=0): # pragma: no cover\n im = np.array(~im, dtype=int)\n if axis == 1:\n im = np.transpose(im, axes=[1, 0, 2])\n if axis == 2:\n im = np.transpose(im, axes=[2, 1, 0])\n im = np.sum(im, axis=0, dtype=np.int64)\n return im","def _ureduce(a, func, **kwargs):\n a = np.asanyarray(a)\n axis = kwargs.get('axis', None)\n if axis is not None:\n keepdim = list(a.shape)\n nd = a.ndim\n axis = _nx.normalize_axis_tuple(axis, nd)\n\n for ax in axis:\n keepdim[ax] = 1\n\n if len(axis) == 1:\n kwargs['axis'] = axis[0]\n else:\n keep = set(range(nd)) - set(axis)\n nkeep = len(keep)\n # swap axis that should not be reduced to front\n for i, s in enumerate(sorted(keep)):\n a = a.swapaxes(i, s)\n # merge reduced axis\n a = a.reshape(a.shape[:nkeep] + (-1,))\n kwargs['axis'] = -1\n keepdim = tuple(keepdim)\n else:\n keepdim = (1,) * a.ndim\n\n r = func(a, **kwargs)\n return r, keepdim","def two_dim(a: cython.double[:,:]):\n a[0,0] *= 3\n return a[0,0], a[0,1], a.ndim","def sf01(arr):\n s = arr.shape\n return arr.swapaxes(0, 1).reshape(s[0] * s[1], *s[2:])","def sf01(arr):\n s = arr.shape\n return arr.swapaxes(0, 1).reshape(s[0] * s[1], *s[2:])","def sf01(arr):\n s = arr.shape\n return arr.swapaxes(0, 1).reshape(s[0] * s[1], *s[2:])","def sf01(arr):\n s = arr.shape\n return arr.swapaxes(0, 1).reshape(s[0] * s[1], *s[2:])","def flip(a, axis):\n a_ndim = a.ndim\n if a_ndim < 1:\n raise core.core._AxisError('Input must be >= 1-d')\n\n axis = int(axis)\n if not -a_ndim <= axis < a_ndim:\n raise core.core._AxisError(\n 'axis must be >= %d and < %d' % (-a_ndim, a_ndim))\n\n return _flip(a, axis)","def reflect(self, axis):\n if axis == \"x\":\n self.y = - self.y\n elif axis == \"y\":\n self.x = - self.x\n else:\n print(\"The argument axis only accepts values 'x' and 'y'!\")","def squeeze(a, axis=None):\n if axis is None:\n axis = tuple(i for i, n in enumerate(a._shape) if n == 1)\n elif isinstance(axis, int):\n axis = axis,\n\n new_shape = []\n new_strides = []\n j = 0\n for i, n in enumerate(a._shape):\n if j < len(axis) and i == axis[j]:\n if n != 1:\n raise RuntimeError('Cannot squeeze dimension of size > 1')\n j += 1\n else:\n new_shape.append(n)\n new_strides.append(a._strides[i])\n\n v = a.view()\n v._shape = tuple(new_shape)\n v._strides = tuple(new_strides)\n v._c_contiguous = -1\n v._f_contiguous = -1\n return v","def _moveaxis(self, arr, source, dest):\n try:\n source = list(source)\n except TypeError:\n source = [source]\n try:\n dest = list(dest)\n except TypeError:\n dest = [dest]\n\n source = [a + arr.ndim if a < 0 else a for a in source]\n dest = [a + arr.ndim if a < 0 else a for a in dest]\n\n order = [n for n in range(arr.ndim) if n not in source]\n\n for dest, src in sorted(zip(dest, source)):\n order.insert(dest, src)\n\n return arr.transpose(order)","def transform(array):\n assert array.shape == (10, 2)\n new = Array(columns=\"abcd\")\n for x, y in array:\n new.append([x, y, x + y, x * y])\n return new","def apply_along_axes(func: Callable, x: np.ndarray, axis: AxesLike, *args, **kwargs):\n axis = check_axes(axis)\n if len(axis) == x.ndim:\n return func(x)\n\n other_axes = negate_indices(axis, x.ndim)\n begin = np.arange(len(other_axes))\n\n y = np.moveaxis(x, other_axes, begin)\n result = np.stack([func(patch, *args, **kwargs) for patch in y.reshape(-1, *extract(x.shape, axis))])\n return np.moveaxis(result.reshape(*y.shape), begin, other_axes)","def normalize(a, axis=None):\n a_sum = a.sum(axis)\n if axis and a.ndim > 1:\n a_sum[a_sum == 0] = 1\n shape = list(a.shape)\n shape[axis] = 1\n a_sum.shape = shape\n\n return a / a_sum","def transform(self, x: Array2D) -> Array2D:","def flip(tensor, axis=None):\n raise NotImplementedError","def unbroadcast(x, *axes):\r\n rval = Rebroadcast(*[(axis, False) for axis in axes])(x)\r\n return theano.tensor.opt.apply_rebroadcast_opt(rval)","def _asarray1d(arr, copy=False):\n if copy:\n return asarray(arr).flatten()\n else:\n return asarray(arr).ravel()","def diff_1(value, axis=0, name=None):\n with tf.name_scope(name or 'diff_1'):\n value = tf.convert_to_tensor(value)\n a = array.slice_from_axis(value, end=-1, axis=axis)\n b = array.slice_from_axis(value, begin=1, axis=axis)\n diff_tensor = b - a\n return diff_tensor","def rollaxis(a, axis, start=0):\n return core.rollaxis(a, axis, start)","def mirror(img):\n return img[:, ::-1]","def expand_dims(array):\n return array[np.newaxis, np.newaxis, ...]","def transform(self,X):\n X=np.array(X)\n if(X.ndim==1):\n return self.transform_1d(X) \n elif(X.ndim==2):\n X_tran=self.transform_1d(X[0])\n for i in range(1,X.shape[0]):\n X_tran=np.vstack((X_tran,self.transform_1d(X[i])))\n return X_tran \n else:\n print(\"Warning: The input array is not Transformed since its greater than 2 dimension\")\n print(\"Its dimension is:{} required is 2\".format(X.ndim))\n return X","def rotoreflection(axis, angle, origin=(0, 0, 0)):\n rot = SymmOp.from_origin_axis_angle(origin, axis, angle)\n refl = SymmOp.reflection(axis, origin)\n m = np.dot(rot.affine_matrix, refl.affine_matrix)\n return SymmOp(m)","def argsort(tensor, axis):\n raise NotImplementedError","def test_broadcast(self):\n a = np.ones((3, 4, 1))\n ai = np.arange(10, dtype=np.intp).reshape((1, 2, 5)) % 4\n put_along_axis(a, ai, 20, axis=1)\n assert_equal(take_along_axis(a, ai, axis=1), 20)","def double(arr):\n newarr = np.array([(xx,xx) for xx in arr]).ravel()\n return newarr","def _get_axis(array, axis_num, i):\n if array.ndim == 2:\n if axis_num == 0:\n return array[i, :]\n elif axis_num == 1:\n return array[:, i]\n else:\n return None\n elif array.ndim == 3:\n if axis_num == 0:\n return array[i, :, :]\n elif axis_num == 1:\n return array[:, i, :]\n elif axis_num == 2:\n return array[:, :, i]\n else:\n return None\n else:\n return None","def _get_axis(array, axis_num, i):\n if array.ndim == 2:\n if axis_num == 0:\n return array[i, :]\n elif axis_num == 1:\n return array[:, i]\n else:\n return None\n elif array.ndim == 3:\n if axis_num == 0:\n return array[i, :, :]\n elif axis_num == 1:\n return array[:, i, :]\n elif axis_num == 2:\n return array[:, :, i]\n else:\n return None\n else:\n return None","def flatten_idx(idx, axis=-1):\n idx = numpy.asanyarray(idx)\n if not idx.dtype.kind in ('i', 'u'):\n idx = idx.astype(int)\n preshape = idx.shape[:axis]\n postshape = idx.shape[axis:]\n stride = int(numpy.product(postshape[1:])) #1 if applied to empty\n #The index on this axis moves stride elements in flat\n outidx = idx.flatten() * stride #makes a copy\n #First add the offsets to get us to [..., idx @ axis = 0, 0...)\n outidx += numpy.repeat(\n numpy.arange(0, len(outidx), int(numpy.product(postshape)),\n dtype=idx.dtype),\n numpy.product(postshape))\n #Now offsets for non-zero on the trailing axes [0, 0, ... 0@axis, ...]\n outidx += numpy.tile(numpy.arange(0, stride, dtype=idx.dtype),\n int(numpy.product(preshape)) * idx.shape[axis])\n return outidx","def rotate(arr, theta, axis=0, backend='autograd', device=None):\n if backend == 'autograd':\n warnings.warn('Rotate (with grad) in Autograd is not yet implemented. Use Pytorch backend instead.')\n axes = []\n for i in range(3):\n if i != axis:\n axes.append(i)\n return scipy.ndimage.rotate(arr, -anp.rad2deg(theta), reshape=False, axes=axes, mode='nearest', order=1)\n elif backend == 'pytorch':\n try:\n theta = theta.view(1)\n except:\n theta = tc.tensor(theta, requires_grad=False, device=device)\n theta = theta.view(1)\n axis_arrangement = [0, 1, 2, 3]\n # Move channel to the 2nd dimension.\n axis_arrangement[1], axis_arrangement[3] = axis_arrangement[3], axis_arrangement[1]\n # Move invariant axis to front.\n if axis != 0:\n q = axis_arrangement.index(axis)\n axis_arrangement[0], axis_arrangement[q] = axis_arrangement[q], axis_arrangement[0]\n if axis_arrangement[2] < axis_arrangement[3]:\n theta = -theta\n arr = permute_axes(arr, axis_arrangement, override_backend='pytorch')\n naught = cast(tc.tensor([0.], device=device), pytorch_dtype_query_mapping_dict[theta.dtype], override_backend='pytorch')\n m0 = tc.cat([tc.cos(theta), -tc.sin(theta), naught])\n m1 = tc.cat([tc.sin(theta), tc.cos(theta), naught])\n m = tc.stack([m0, m1]).view(1, 2, 3)\n m = cast(tile(m, [arr.shape[0], 1, 1], override_backend='pytorch'), pytorch_dtype_query_mapping_dict[arr.dtype], override_backend='pytorch')\n g = tc.nn.functional.affine_grid(m, arr.shape, align_corners=False)\n\n arr = tc.nn.functional.grid_sample(arr, g, padding_mode='border', align_corners=False)\n arr = permute_axes(arr, [axis_arrangement.index(0), axis_arrangement.index(1),\n axis_arrangement.index(2), axis_arrangement.index(3)], override_backend='pytorch')\n return arr","def __call__(self, array):\n result = numpy.empty_like(array)\n result[:] = _INDEX_NODATA\n valid_mask = array != _INDEX_NODATA\n result[valid_mask] = array[valid_mask] * self.scalar\n return result","def assure_2d(array):\n array = np.array(array, copy=False, subok=True, ndmin=1)\n if array.ndim == 2:\n return array\n elif array.ndim == 1:\n return array[:, np.newaxis]\n else:\n raise RuntimeError(\"Array must be 1 or 2 dimensional.\")","def __normalize_after_fft(arr):\n\n n1, n2 = arr.shape[0], arr.shape[1]\n for i in range(n1):\n for j in range(n2):\n arr[i, j] *= n1 * n2\n\n return arr","def take_along_axis(x1, indices, axis):\n\n x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)\n indices_desc = dpnp.get_dpnp_descriptor(\n indices, copy_when_nondefault_queue=False\n )\n if x1_desc and indices_desc:\n if x1_desc.ndim != indices_desc.ndim:\n pass\n elif not isinstance(axis, int):\n pass\n elif axis >= x1_desc.ndim:\n pass\n elif x1_desc.ndim == indices_desc.ndim:\n val_list = []\n for i in list(indices_desc.shape)[:-1]:\n if i == 1:\n val_list.append(True)\n else:\n val_list.append(False)\n if not all(val_list):\n pass\n else:\n return dpnp_take_along_axis(x1, indices, axis)\n else:\n return dpnp_take_along_axis(x1, indices, axis)\n\n return call_origin(numpy.take_along_axis, x1, indices, axis)","def broadcast_array(array, axis_index, shape):\n\n if type(axis_index) in [float, int]:\n start_axis_index = end_axis_index = axis_index\n else:\n assert len(axis_index) == 2\n start_axis_index, end_axis_index = axis_index\n \n dim = start_axis_index - 1\n while dim >= 0:\n array = array[numpy.newaxis, ...]\n array = numpy.repeat(array, shape[dim], axis=0)\n dim = dim - 1\n \n dim = end_axis_index + 1\n while dim < len(shape): \n array = array[..., numpy.newaxis]\n array = numpy.repeat(array, shape[dim], axis=-1)\n dim = dim + 1\n\n return array","def _get_first_unmasked_data(array, axis):\n mask = da.ma.getmaskarray(array)\n numerical_mask = da.where(mask, -1.0, 1.0)\n indices_first_positive = da.argmax(numerical_mask, axis=axis)\n indices = da.meshgrid(\n *[da.arange(array.shape[i]) for i in range(array.ndim) if i != axis],\n indexing='ij')\n indices.insert(axis, indices_first_positive)\n first_unmasked_data = np.array(array)[tuple(indices)]\n return first_unmasked_data","def rotate_arr(self, first: int):\n\n return self.arr[first:] + self.arr[0:first]","def f1to2(x):\n assert_equal(x.ndim, 1)\n return (x[::-1] * x[1:,None]).view(cls)","def img_add_flip(arr, flip_horiz = True, flip_vert = False):\r\n assert len(arr.shape) == 3, \"'arr' input array must be three dimensional\"\r\n arr_copy = arr.copy()\r\n if flip_horiz:\r\n arr_copy = np.fliplr(arr_copy)\r\n if flip_vert:\r\n arr_copy = np.flipud(arr_copy)\r\n return arr_copy","def copnorm_nd(x, axis=-1):\n assert isinstance(x, np.ndarray) and (x.ndim >= 1)\n return np.apply_along_axis(copnorm_1d, axis, x)","def copnorm_nd(x, axis=-1):\n assert isinstance(x, np.ndarray) and (x.ndim >= 1)\n return np.apply_along_axis(copnorm_1d, axis, x)","def transpose(x):\n return x[:, np.newaxis]","def _frz(a):\n if a.ndim == 0:\n a.shape = (1,)\n return a","def _expand(x, ndim, axis=0):\n while F.rank(x) < ndim:\n x = F.expand_dims(x, axis)\n return x","def perturb(self, idx, axis=0, keep_changes=False):\n \n return self._method(idx, axis, keep_changes)","def sliceForAxis(arr, axis=-1, start=None, stop=None, step=None):\n\n if (start is stop is step is None):\n raise RuntimeError(\"``start``,``stop``, or ``step`` required!\")\n\n ndim = np.ndim(arr)\n if (ndim == 0):\n ndim = arr\n\n if (ndim > 1):\n # Create an object to slice all elements of all dims\n cut = [slice(None)]*ndim\n # Exclude the last element of the last dimension\n cut[axis] = slice(start, stop, step)\n cut = tuple(cut)\n else:\n if (axis != 0) and (axis != -1):\n raise RuntimeError(\"cannot slice nonexistent axis!\")\n cut = slice(start, stop, step)\n\n return cut","def identity( array ):\n return _myarray.identity( array )","def addem(inarr):\n return np.expand_dims(inarr, axis=1)","def autocorrelate(x):\n\n global i1, i2\n # used for transposes\n t = roll(range(x.ndim), 1)\n\n # pairs of indexes\n # the first is for the autocorrelation array\n # the second is the shift\n ii = [list(enumerate(range(1, s - 1))) for s in x.shape]\n\n # initialize the resulting autocorrelation array\n acor = empty(shape=[len(s0) for s0 in ii])\n\n # iterate over all combinations of directional shifts\n for i in product(*ii):\n # extract the indexes for\n # the autocorrelation array\n # and original array respectively\n i1, i2 = asarray(i).T\n\n x1 = x.copy()\n x2 = x.copy()\n\n for i0 in i2:\n # clip the unshifted array at the end\n x1 = x1[:-i0]\n # and the shifted array at the beginning\n x2 = x2[i0:]\n\n # prepare to do the same for\n # the next axis\n x1 = x1.transpose(t)\n x2 = x2.transpose(t)\n\n # normalize shifted and unshifted arrays\n x1 -= x1.mean()\n x1 /= x1.std()\n x2 -= x2.mean()\n x2 /= x2.std()\n\n # compute the autocorrelation directly\n # from the definition\n acor[tuple(i1)] = (x1 * x2).mean()\n\n return acor","def take_along_axis(a, indices, axis):\n\n if indices.dtype.kind not in ('i', 'u'):\n raise IndexError('`indices` must be an integer array')\n\n if axis is None:\n a = a.ravel()\n axis = 0\n\n ndim = a.ndim\n\n axis = internal._normalize_axis_index(axis, ndim)\n\n if ndim != indices.ndim:\n raise ValueError(\n '`indices` and `a` must have the same number of dimensions')\n\n fancy_index = []\n for i, n in enumerate(a.shape):\n if i == axis:\n fancy_index.append(indices)\n else:\n ind_shape = (1,) * i + (-1,) + (1,) * (ndim - i - 1)\n fancy_index.append(cupy.arange(n).reshape(ind_shape))\n\n return a[tuple(fancy_index)]","def strip_array_wrappers(arry):\n curr = arry\n if curr.ndim == 0:\n if isinstance(curr[...], np.ndarray):\n return strip_array_wrappers(curr[...])\n return curr\n\n # there is a possibility for infinite looping\n # e.g. [np.ndarray, str, dict] would stay object array\n # impossible if homogeneous (implied by 1-element wrappers)\n while isinstance(curr[0], np.ndarray):\n if curr.shape[0] == 1:\n curr = curr[0]\n else:\n curr = np.array(tuple(curr))\n\n return curr","def collapse_dims(\n arr: JaggedArray, axis: int = -1, inplace: bool = False\n) -> JaggedArray:\n\n assert axis != 0, \"cannot collapse the zero'th axis\"\n\n if axis < 0:\n axis += arr.ndim\n\n keepdims = np.delete(np.arange(arr.ndim), (axis - 1, axis - 2))\n newshape = arr.shape[axis - 2] * arr.shape[axis - 1]\n\n if not keepdims.size:\n shape = np.expand_dims(newshape, 0)\n else:\n shape = np.concatenate([arr.shape[: axis - 2], newshape], axis=1)\n\n if not inplace:\n arr = arr.copy()\n arr.shape = shape\n return arr","def permute(self, ordering: np.ndarray, *, axis: int) -> None:\n\t\tif axis == 0:\n\t\t\tself.values = self.values[ordering, :]\n\t\telif axis == 1:\n\t\t\tself.values = self.values[:, ordering]\n\t\telse:\n\t\t\traise ValueError(\"axis must be 0 or 1\")","def tilda_x(X):\n return np.c_[np.ones(X.shape[0]), X]","def shift(x, row_ind, col_ind, row_axis=0, col_axis=1, channel_axis=2,\n fill_mode='constant', cval=0.):\n h, w = x.shape[row_axis], x.shape[col_axis]\n tx = row_ind - (h / 2)\n ty = col_ind - (w / 2) \n translation_matrix = np.array([[1, 0, tx],\n [0, 1, ty],\n [0, 0, 1]])\n\n transform_matrix = translation_matrix # no need to do offset\n x = apply_transform(x, transform_matrix, channel_axis, fill_mode, cval)\n \n return x","def rotate_along(axis: Tensor) -> Tensor:\n W = torch.einsum('ijk,j->ik', levi_civita.to(axis), axis)\n return expm(W)","def convert_take_along_axis(g, op, block):\n\n x = g.get_node(op.input(\"Input\")[0])\n idx = g.get_node(op.input(\"Index\")[0])\n axis = op.attr(\"Axis\")\n out = _op.gather(x, axis, idx)\n g.add_node(op.output(\"Result\")[0], out)","def put_along_axis(x1, indices, values, axis):\n\n x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)\n indices_desc = dpnp.get_dpnp_descriptor(\n indices, copy_when_nondefault_queue=False\n )\n values_desc = dpnp.get_dpnp_descriptor(\n values, copy_when_nondefault_queue=False\n )\n if x1_desc and indices_desc and values_desc:\n if x1_desc.ndim != indices_desc.ndim:\n pass\n elif not isinstance(axis, int):\n pass\n elif axis >= x1_desc.ndim:\n pass\n elif indices_desc.size != values_desc.size:\n pass\n else:\n return dpnp_put_along_axis(x1_desc, indices_desc, values_desc, axis)\n\n return call_origin(\n numpy.put_along_axis, x1, indices, values, axis, dpnp_inplace=True\n )","def apply(self, array: Tuple['Nparray']) -> 'FqeData':\n\n out = copy.deepcopy(self)\n out.apply_inplace(array)\n return out","def test_direct_shape():\n\n n = 21\n x = np.ones((n, n))\n\n recon = abel.direct.direct_transform(x, direction='forward')\n assert recon.shape == (n, n) \n\n recon = abel.direct.direct_transform(x, direction='inverse')\n assert recon.shape == (n, n)","def flip(x, dim):\n dim = x.dim() + dim if dim < 0 else dim\n inds = tuple(slice(None, None) if i != dim\n else x.new(torch.arange(x.size(i) - 1, -1, -1).tolist()).long()\n for i in range(x.dim()))\n return x[inds]","def _roll_once(\n tensor: tf.Tensor,\n shift: int,\n axis: int,\n) -> tf.Tensor:\n if not shift:\n return tensor\n axis = _normalize_axis(axis, len(tensor.shape))\n slice_left = (slice(None),) * axis + (slice(-shift, None),)\n slice_right = (slice(None),) * axis + (slice(None, -shift),)\n return tf.concat([tensor[slice_left], tensor[slice_right]], axis=axis)","def extract_into_tensor(arr, timesteps, broadcast_shape):\n device = timesteps.device\n assert arr.device == device\n res = arr[timesteps].float()\n new_dims = [1] * (len(broadcast_shape) - res.ndim)\n res = res.view(*res.shape, *new_dims)\n return torch.broadcast_to(res, broadcast_shape)","def expand_dims_twice(array):\n return np.expand_dims(np.expand_dims(array, axis=1), axis=1)","def transform(x: np.array, params: TransformParams) -> np.array:\n if params.do_hor_flip:\n x = flip_axis(x, 1)\n\n if params.do_vert_flip:\n x = flip_axis(x, 0)\n\n return x","def wrap(array):\n\t\t\t\n\t\t\tassert array.ndim == 2, ('works on 2D arrays only; expecting '\n\t\t\t\t\t\t\t\t\t 'self.cond_tuning, which should be 2D')\n\t\t\t\t\t\t\t\t\t\t\t\n\t\t\treturn np.column_stack((array, array[..., 0]))","def index(x, axis, index_spec):\n idx = [slice(None)] * x.ndim\n idx[axis] = index_spec\n\n indexer = tuple(idx)\n return indexer","def __call__(self, axis=None):\n # verify axis param, discard value\n self._obj._is_sequence_axis(axis)\n return self.__class__(self._obj, axis=axis)","def reflection_pad2d(self, x, pad=1):\n x = torch.cat([torch.flip(x[:, :, 1:pad + 1, :], [2]), x, torch.flip(x[:, :, -pad - 1:-1, :], [2])], 2)\n x = torch.cat([torch.flip(x[:, :, :, 1:pad + 1], [3]), x, torch.flip(x[:, :, :, -pad - 1:-1], [3])], 3)\n return x","def naive_act_norm_initialize(x, axis):\n x = np.asarray(x)\n axis = list(sorted(set([a + len(x.shape) if a < 0 else a for a in axis])))\n min_axis = np.min(axis)\n reduce_axis = tuple(a for a in range(len(x.shape)) if a not in axis)\n var_shape = [x.shape[a] for a in axis]\n var_shape_aligned = [x.shape[a] if a in axis else 1\n for a in range(min_axis, len(x.shape))]\n mean = np.reshape(np.mean(x, axis=reduce_axis), var_shape)\n bias = -mean\n scale = 1. / np.reshape(\n np.sqrt(np.mean((x - np.reshape(mean, var_shape_aligned)) ** 2,\n axis=reduce_axis)),\n var_shape\n )\n return scale, bias, var_shape_aligned","def flatten(self, arr):\n shape = arr.shape\n return arr.reshape(shape[0] * shape[1], *shape[2:])","def standardize_single_array(x):\n if x is None:\n return None\n if tensor_util.is_tensor(x):\n x_shape_ndims = array_ops.rank(x)\n else:\n x_shape_ndims = len(x.shape)\n\n if (x_shape_ndims == 1 and (expected_shape is None or len(expected_shape) != 1)):\n if tensor_util.is_tensor(x):\n x = array_ops.expand_dims(x, axis=1)\n else:\n x = np.expand_dims(x, 1)\n return x","def matricize(X, axis):\n # If negative axis is passed, convert to equivalent positive form\n if axis < 0:\n axis = X.ndim + axis\n # Need to transpose so that ordering is correct\n # X.shape = (7, 3, 11)\n # matricize(X, 0).shape = (7, 11 * 3)\n # matricize(X, 1).shape = (3, 11 * 7)\n # matricize(X, 2).shape = (11, 3 * 7)\n # Long term, may need an option to specify whether to reverse or not\n not_axis = np.where(np.arange(X.ndim) != axis)[0][::-1]\n return X.transpose(axis, *not_axis).reshape(X.shape[axis], -1)","def observation(self, obs):\n\n# import pdb;pdb.set_trace()\n return np.moveaxis(obs, 2, 0)","def transpose_inplace(x, **kwargs):\r\n dims = range(x.ndim-1, -1, -1)\r\n return elemwise.DimShuffle(x.broadcastable, dims, inplace=True)(x)","def getslice(arr: tf.Tensor, slice: tf.Tensor, axis: int) -> tf.Tensor:\n if arr is None:\n return None\n return tf.boolean_mask(arr, slice, axis=axis)","def __get_transformed_axis__(data, c, x):\n dx = data[c]\n dx -= x[0]\n dx /= x[-1] - x[0]\n dx *= x.shape[0]\n dx = np.round(x)\n return np.int32(dx)","def nonzero_last(arr, *, axis):\n def nonzero_last_1d(arr):\n try:\n return np.nonzero(arr)[0][-1]\n except IndexError:\n return -1\n return np.apply_along_axis(nonzero_last_1d, axis, arr)","def fliplr(a):\n if a.ndim < 2:\n raise ValueError('Input must be >= 2-d')\n return a[::, ::-1]","def unfold_axis(data, k):\n\n target_dim = k\n total_dim = len(data.shape)\n\n dim_list = []\n for i in range(total_dim):\n dim_list.append((target_dim - i) % total_dim)\n dim_order = tuple(dim_list)\n\n data_unfold = np.transpose(data,dim_order)\n data_unfold = np.reshape(data_unfold,[data.shape[k],int(data.size/data.shape[k])])\n return data_unfold","def velocity_interpolation(a, axis=-1):\n nd = len(a.shape)\n\n # adding one extra dimension to field at the lower boundary with\n # zeros.\n a_shape = list(a.shape)\n a_shape[axis] = a.shape[axis] + 1\n a_shape = tuple(a_shape)\n slice0 = [slice(None)] * nd\n slice0[axis] = slice(1, None)\n slice0 = tuple(slice0)\n a_prim = np.zeros(a_shape)\n a_prim[slice0] = a\n\n # doing the interpolation\n slice1 = [slice(None)] * nd\n slice2 = [slice(None)] * nd\n slice1[axis] = slice(None, -1)\n slice2[axis] = slice(1, None)\n slice1 = tuple(slice1)\n slice2 = tuple(slice2)\n\n a_interp = (a_prim[slice1] + a_prim[slice2])/2\n return a_interp"],"string":"[\n \"def reflect_array(x, axis=1, kind='even'):\\n if axis == 0:\\n x_sym = np.flipud(x)\\n elif axis == 1:\\n x_sym = np.fliplr(x)\\n else:\\n raise NotImplementedError\\n\\n if kind == 'even':\\n fact = 1.0\\n elif kind == 'odd':\\n fact = -1.0\\n else:\\n raise NotImplementedError\\n\\n return np.concatenate((fact*x_sym, x), axis=axis)\",\n \"def _np_apply_along_axis(func1d, axis: int, arr: np.ndarray) -> np.ndarray:\\n\\n assert arr.ndim == 2\\n assert axis in [0, 1]\\n\\n if axis == 0:\\n result = np.empty(arr.shape[1])\\n for i in range(len(result)):\\n result[i] = func1d(arr[:, i])\\n return result\\n\\n result = np.empty(arr.shape[0])\\n for i in range(len(result)):\\n result[i] = func1d(arr[i, :])\\n\\n return result\",\n \"def __call__(self, array, axis=None):\\n raise NotImplementedError()\",\n \"def steppify(arr, axis='x'):\\n\\t\\n\\tif axis == 'x':\\n\\t\\tnewarr = np.r_[arr[0], np.dstack((arr[1:], arr[1:])).flatten()]\\n\\t\\n\\telif axis == 'y':\\n\\t\\tnewarr = np.r_[np.dstack((arr[:-1], arr[:-1])).flatten(), arr[-1]]\\n\\t\\n\\telse:\\n\\t\\tprint('your axes in steppify are improperly identified')\\n\\n\\treturn newarr\",\n \"def shuffle_array_along(X, axis=0, inline=True):\\n if not inline:\\n X = X.copy()\\n np.apply_along_axis(np.random.shuffle, axis, X)\\n if not inline:\\n return X\",\n \"def one_dim(a: cython.double[:]):\\n a[0] *= 2\\n return a[0], a.ndim\",\n \"def nonzero_first(arr, *, axis):\\n def nonzero_first_1d(arr):\\n try:\\n return np.nonzero(arr)[0][0]\\n except IndexError:\\n return -1\\n return np.apply_along_axis(nonzero_first_1d, axis, arr)\",\n \"def forward_one(self, x):\\n return np.squeeze(self.forward(x[np.newaxis,:]), axis=0)\",\n \"def _asvector(self, arr):\\n result = self._moveaxis(arr, [-2, -1], [0, 1])\\n return self.domain.element(result)\",\n \"def real(x):\\n return x[..., 0]\",\n \"def _chk_asarray(a, axis):\\r\\n if axis is None:\\r\\n a = ravel(a)\\r\\n outaxis = 0\\r\\n else:\\r\\n a = asarray(a)\\r\\n outaxis = axis\\r\\n return a, outaxis\",\n \"def trans(array,dim):\\n return array[filter(lambda x: x != dim,range(len(array)) ) ]\",\n \"def _swap_axis(input_tensor, dim_index, last_index, name=None):\\n return array_ops.transpose(\\n input_tensor,\\n array_ops.concat([\\n math_ops.range(dim_index), [last_index],\\n math_ops.range(dim_index + 1, last_index), [dim_index]\\n ], 0),\\n name=name)\",\n \"def reflect(self):\\n self.vertices[-1, :] = self.reflected\",\n \"def apply_array(self, array: np.ndarray) -> np.ndarray:\\n functions = (\\n f for f, b in zip((np.transpose, np.fliplr, np.flipud), astuple(self)) if b\\n )\\n return reduce(lambda f, g: lambda x: g(f(x)), functions, lambda x: x)(array)\",\n \"def test_broadcast(self):\\n a = np.ones((3, 4, 1))\\n ai = np.ones((1, 2, 5), dtype=np.intp)\\n actual = take_along_axis(a, ai, axis=1)\\n assert_equal(actual.shape, (3, 2, 5))\",\n \"def indep_roll(arr, shifts, axis=1):\\n arr = np.swapaxes(arr, axis, -1)\\n all_idcs = np.ogrid[[slice(0, n) for n in arr.shape]]\\n\\n # Convert to a positive shift\\n shifts[shifts < 0] += arr.shape[-1]\\n all_idcs[-1] = all_idcs[-1] - shifts[:, np.newaxis]\\n\\n result = arr[tuple(all_idcs)]\\n arr = np.swapaxes(result, -1, axis)\\n return arr\",\n \"def corresponding_ravel(X,axis=0):\\n\\n t1=np.c_[tuple([di.ravel() for di in X])]\\n\\n if axis==1:\\n t1=t1.T\\n\\n return t1\",\n \"def xray(im, axis=0): # pragma: no cover\\n im = np.array(~im, dtype=int)\\n if axis == 1:\\n im = np.transpose(im, axes=[1, 0, 2])\\n if axis == 2:\\n im = np.transpose(im, axes=[2, 1, 0])\\n im = np.sum(im, axis=0, dtype=np.int64)\\n return im\",\n \"def _ureduce(a, func, **kwargs):\\n a = np.asanyarray(a)\\n axis = kwargs.get('axis', None)\\n if axis is not None:\\n keepdim = list(a.shape)\\n nd = a.ndim\\n axis = _nx.normalize_axis_tuple(axis, nd)\\n\\n for ax in axis:\\n keepdim[ax] = 1\\n\\n if len(axis) == 1:\\n kwargs['axis'] = axis[0]\\n else:\\n keep = set(range(nd)) - set(axis)\\n nkeep = len(keep)\\n # swap axis that should not be reduced to front\\n for i, s in enumerate(sorted(keep)):\\n a = a.swapaxes(i, s)\\n # merge reduced axis\\n a = a.reshape(a.shape[:nkeep] + (-1,))\\n kwargs['axis'] = -1\\n keepdim = tuple(keepdim)\\n else:\\n keepdim = (1,) * a.ndim\\n\\n r = func(a, **kwargs)\\n return r, keepdim\",\n \"def two_dim(a: cython.double[:,:]):\\n a[0,0] *= 3\\n return a[0,0], a[0,1], a.ndim\",\n \"def sf01(arr):\\n s = arr.shape\\n return arr.swapaxes(0, 1).reshape(s[0] * s[1], *s[2:])\",\n \"def sf01(arr):\\n s = arr.shape\\n return arr.swapaxes(0, 1).reshape(s[0] * s[1], *s[2:])\",\n \"def sf01(arr):\\n s = arr.shape\\n return arr.swapaxes(0, 1).reshape(s[0] * s[1], *s[2:])\",\n \"def sf01(arr):\\n s = arr.shape\\n return arr.swapaxes(0, 1).reshape(s[0] * s[1], *s[2:])\",\n \"def flip(a, axis):\\n a_ndim = a.ndim\\n if a_ndim < 1:\\n raise core.core._AxisError('Input must be >= 1-d')\\n\\n axis = int(axis)\\n if not -a_ndim <= axis < a_ndim:\\n raise core.core._AxisError(\\n 'axis must be >= %d and < %d' % (-a_ndim, a_ndim))\\n\\n return _flip(a, axis)\",\n \"def reflect(self, axis):\\n if axis == \\\"x\\\":\\n self.y = - self.y\\n elif axis == \\\"y\\\":\\n self.x = - self.x\\n else:\\n print(\\\"The argument axis only accepts values 'x' and 'y'!\\\")\",\n \"def squeeze(a, axis=None):\\n if axis is None:\\n axis = tuple(i for i, n in enumerate(a._shape) if n == 1)\\n elif isinstance(axis, int):\\n axis = axis,\\n\\n new_shape = []\\n new_strides = []\\n j = 0\\n for i, n in enumerate(a._shape):\\n if j < len(axis) and i == axis[j]:\\n if n != 1:\\n raise RuntimeError('Cannot squeeze dimension of size > 1')\\n j += 1\\n else:\\n new_shape.append(n)\\n new_strides.append(a._strides[i])\\n\\n v = a.view()\\n v._shape = tuple(new_shape)\\n v._strides = tuple(new_strides)\\n v._c_contiguous = -1\\n v._f_contiguous = -1\\n return v\",\n \"def _moveaxis(self, arr, source, dest):\\n try:\\n source = list(source)\\n except TypeError:\\n source = [source]\\n try:\\n dest = list(dest)\\n except TypeError:\\n dest = [dest]\\n\\n source = [a + arr.ndim if a < 0 else a for a in source]\\n dest = [a + arr.ndim if a < 0 else a for a in dest]\\n\\n order = [n for n in range(arr.ndim) if n not in source]\\n\\n for dest, src in sorted(zip(dest, source)):\\n order.insert(dest, src)\\n\\n return arr.transpose(order)\",\n \"def transform(array):\\n assert array.shape == (10, 2)\\n new = Array(columns=\\\"abcd\\\")\\n for x, y in array:\\n new.append([x, y, x + y, x * y])\\n return new\",\n \"def apply_along_axes(func: Callable, x: np.ndarray, axis: AxesLike, *args, **kwargs):\\n axis = check_axes(axis)\\n if len(axis) == x.ndim:\\n return func(x)\\n\\n other_axes = negate_indices(axis, x.ndim)\\n begin = np.arange(len(other_axes))\\n\\n y = np.moveaxis(x, other_axes, begin)\\n result = np.stack([func(patch, *args, **kwargs) for patch in y.reshape(-1, *extract(x.shape, axis))])\\n return np.moveaxis(result.reshape(*y.shape), begin, other_axes)\",\n \"def normalize(a, axis=None):\\n a_sum = a.sum(axis)\\n if axis and a.ndim > 1:\\n a_sum[a_sum == 0] = 1\\n shape = list(a.shape)\\n shape[axis] = 1\\n a_sum.shape = shape\\n\\n return a / a_sum\",\n \"def transform(self, x: Array2D) -> Array2D:\",\n \"def flip(tensor, axis=None):\\n raise NotImplementedError\",\n \"def unbroadcast(x, *axes):\\r\\n rval = Rebroadcast(*[(axis, False) for axis in axes])(x)\\r\\n return theano.tensor.opt.apply_rebroadcast_opt(rval)\",\n \"def _asarray1d(arr, copy=False):\\n if copy:\\n return asarray(arr).flatten()\\n else:\\n return asarray(arr).ravel()\",\n \"def diff_1(value, axis=0, name=None):\\n with tf.name_scope(name or 'diff_1'):\\n value = tf.convert_to_tensor(value)\\n a = array.slice_from_axis(value, end=-1, axis=axis)\\n b = array.slice_from_axis(value, begin=1, axis=axis)\\n diff_tensor = b - a\\n return diff_tensor\",\n \"def rollaxis(a, axis, start=0):\\n return core.rollaxis(a, axis, start)\",\n \"def mirror(img):\\n return img[:, ::-1]\",\n \"def expand_dims(array):\\n return array[np.newaxis, np.newaxis, ...]\",\n \"def transform(self,X):\\n X=np.array(X)\\n if(X.ndim==1):\\n return self.transform_1d(X) \\n elif(X.ndim==2):\\n X_tran=self.transform_1d(X[0])\\n for i in range(1,X.shape[0]):\\n X_tran=np.vstack((X_tran,self.transform_1d(X[i])))\\n return X_tran \\n else:\\n print(\\\"Warning: The input array is not Transformed since its greater than 2 dimension\\\")\\n print(\\\"Its dimension is:{} required is 2\\\".format(X.ndim))\\n return X\",\n \"def rotoreflection(axis, angle, origin=(0, 0, 0)):\\n rot = SymmOp.from_origin_axis_angle(origin, axis, angle)\\n refl = SymmOp.reflection(axis, origin)\\n m = np.dot(rot.affine_matrix, refl.affine_matrix)\\n return SymmOp(m)\",\n \"def argsort(tensor, axis):\\n raise NotImplementedError\",\n \"def test_broadcast(self):\\n a = np.ones((3, 4, 1))\\n ai = np.arange(10, dtype=np.intp).reshape((1, 2, 5)) % 4\\n put_along_axis(a, ai, 20, axis=1)\\n assert_equal(take_along_axis(a, ai, axis=1), 20)\",\n \"def double(arr):\\n newarr = np.array([(xx,xx) for xx in arr]).ravel()\\n return newarr\",\n \"def _get_axis(array, axis_num, i):\\n if array.ndim == 2:\\n if axis_num == 0:\\n return array[i, :]\\n elif axis_num == 1:\\n return array[:, i]\\n else:\\n return None\\n elif array.ndim == 3:\\n if axis_num == 0:\\n return array[i, :, :]\\n elif axis_num == 1:\\n return array[:, i, :]\\n elif axis_num == 2:\\n return array[:, :, i]\\n else:\\n return None\\n else:\\n return None\",\n \"def _get_axis(array, axis_num, i):\\n if array.ndim == 2:\\n if axis_num == 0:\\n return array[i, :]\\n elif axis_num == 1:\\n return array[:, i]\\n else:\\n return None\\n elif array.ndim == 3:\\n if axis_num == 0:\\n return array[i, :, :]\\n elif axis_num == 1:\\n return array[:, i, :]\\n elif axis_num == 2:\\n return array[:, :, i]\\n else:\\n return None\\n else:\\n return None\",\n \"def flatten_idx(idx, axis=-1):\\n idx = numpy.asanyarray(idx)\\n if not idx.dtype.kind in ('i', 'u'):\\n idx = idx.astype(int)\\n preshape = idx.shape[:axis]\\n postshape = idx.shape[axis:]\\n stride = int(numpy.product(postshape[1:])) #1 if applied to empty\\n #The index on this axis moves stride elements in flat\\n outidx = idx.flatten() * stride #makes a copy\\n #First add the offsets to get us to [..., idx @ axis = 0, 0...)\\n outidx += numpy.repeat(\\n numpy.arange(0, len(outidx), int(numpy.product(postshape)),\\n dtype=idx.dtype),\\n numpy.product(postshape))\\n #Now offsets for non-zero on the trailing axes [0, 0, ... 0@axis, ...]\\n outidx += numpy.tile(numpy.arange(0, stride, dtype=idx.dtype),\\n int(numpy.product(preshape)) * idx.shape[axis])\\n return outidx\",\n \"def rotate(arr, theta, axis=0, backend='autograd', device=None):\\n if backend == 'autograd':\\n warnings.warn('Rotate (with grad) in Autograd is not yet implemented. Use Pytorch backend instead.')\\n axes = []\\n for i in range(3):\\n if i != axis:\\n axes.append(i)\\n return scipy.ndimage.rotate(arr, -anp.rad2deg(theta), reshape=False, axes=axes, mode='nearest', order=1)\\n elif backend == 'pytorch':\\n try:\\n theta = theta.view(1)\\n except:\\n theta = tc.tensor(theta, requires_grad=False, device=device)\\n theta = theta.view(1)\\n axis_arrangement = [0, 1, 2, 3]\\n # Move channel to the 2nd dimension.\\n axis_arrangement[1], axis_arrangement[3] = axis_arrangement[3], axis_arrangement[1]\\n # Move invariant axis to front.\\n if axis != 0:\\n q = axis_arrangement.index(axis)\\n axis_arrangement[0], axis_arrangement[q] = axis_arrangement[q], axis_arrangement[0]\\n if axis_arrangement[2] < axis_arrangement[3]:\\n theta = -theta\\n arr = permute_axes(arr, axis_arrangement, override_backend='pytorch')\\n naught = cast(tc.tensor([0.], device=device), pytorch_dtype_query_mapping_dict[theta.dtype], override_backend='pytorch')\\n m0 = tc.cat([tc.cos(theta), -tc.sin(theta), naught])\\n m1 = tc.cat([tc.sin(theta), tc.cos(theta), naught])\\n m = tc.stack([m0, m1]).view(1, 2, 3)\\n m = cast(tile(m, [arr.shape[0], 1, 1], override_backend='pytorch'), pytorch_dtype_query_mapping_dict[arr.dtype], override_backend='pytorch')\\n g = tc.nn.functional.affine_grid(m, arr.shape, align_corners=False)\\n\\n arr = tc.nn.functional.grid_sample(arr, g, padding_mode='border', align_corners=False)\\n arr = permute_axes(arr, [axis_arrangement.index(0), axis_arrangement.index(1),\\n axis_arrangement.index(2), axis_arrangement.index(3)], override_backend='pytorch')\\n return arr\",\n \"def __call__(self, array):\\n result = numpy.empty_like(array)\\n result[:] = _INDEX_NODATA\\n valid_mask = array != _INDEX_NODATA\\n result[valid_mask] = array[valid_mask] * self.scalar\\n return result\",\n \"def assure_2d(array):\\n array = np.array(array, copy=False, subok=True, ndmin=1)\\n if array.ndim == 2:\\n return array\\n elif array.ndim == 1:\\n return array[:, np.newaxis]\\n else:\\n raise RuntimeError(\\\"Array must be 1 or 2 dimensional.\\\")\",\n \"def __normalize_after_fft(arr):\\n\\n n1, n2 = arr.shape[0], arr.shape[1]\\n for i in range(n1):\\n for j in range(n2):\\n arr[i, j] *= n1 * n2\\n\\n return arr\",\n \"def take_along_axis(x1, indices, axis):\\n\\n x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)\\n indices_desc = dpnp.get_dpnp_descriptor(\\n indices, copy_when_nondefault_queue=False\\n )\\n if x1_desc and indices_desc:\\n if x1_desc.ndim != indices_desc.ndim:\\n pass\\n elif not isinstance(axis, int):\\n pass\\n elif axis >= x1_desc.ndim:\\n pass\\n elif x1_desc.ndim == indices_desc.ndim:\\n val_list = []\\n for i in list(indices_desc.shape)[:-1]:\\n if i == 1:\\n val_list.append(True)\\n else:\\n val_list.append(False)\\n if not all(val_list):\\n pass\\n else:\\n return dpnp_take_along_axis(x1, indices, axis)\\n else:\\n return dpnp_take_along_axis(x1, indices, axis)\\n\\n return call_origin(numpy.take_along_axis, x1, indices, axis)\",\n \"def broadcast_array(array, axis_index, shape):\\n\\n if type(axis_index) in [float, int]:\\n start_axis_index = end_axis_index = axis_index\\n else:\\n assert len(axis_index) == 2\\n start_axis_index, end_axis_index = axis_index\\n \\n dim = start_axis_index - 1\\n while dim >= 0:\\n array = array[numpy.newaxis, ...]\\n array = numpy.repeat(array, shape[dim], axis=0)\\n dim = dim - 1\\n \\n dim = end_axis_index + 1\\n while dim < len(shape): \\n array = array[..., numpy.newaxis]\\n array = numpy.repeat(array, shape[dim], axis=-1)\\n dim = dim + 1\\n\\n return array\",\n \"def _get_first_unmasked_data(array, axis):\\n mask = da.ma.getmaskarray(array)\\n numerical_mask = da.where(mask, -1.0, 1.0)\\n indices_first_positive = da.argmax(numerical_mask, axis=axis)\\n indices = da.meshgrid(\\n *[da.arange(array.shape[i]) for i in range(array.ndim) if i != axis],\\n indexing='ij')\\n indices.insert(axis, indices_first_positive)\\n first_unmasked_data = np.array(array)[tuple(indices)]\\n return first_unmasked_data\",\n \"def rotate_arr(self, first: int):\\n\\n return self.arr[first:] + self.arr[0:first]\",\n \"def f1to2(x):\\n assert_equal(x.ndim, 1)\\n return (x[::-1] * x[1:,None]).view(cls)\",\n \"def img_add_flip(arr, flip_horiz = True, flip_vert = False):\\r\\n assert len(arr.shape) == 3, \\\"'arr' input array must be three dimensional\\\"\\r\\n arr_copy = arr.copy()\\r\\n if flip_horiz:\\r\\n arr_copy = np.fliplr(arr_copy)\\r\\n if flip_vert:\\r\\n arr_copy = np.flipud(arr_copy)\\r\\n return arr_copy\",\n \"def copnorm_nd(x, axis=-1):\\n assert isinstance(x, np.ndarray) and (x.ndim >= 1)\\n return np.apply_along_axis(copnorm_1d, axis, x)\",\n \"def copnorm_nd(x, axis=-1):\\n assert isinstance(x, np.ndarray) and (x.ndim >= 1)\\n return np.apply_along_axis(copnorm_1d, axis, x)\",\n \"def transpose(x):\\n return x[:, np.newaxis]\",\n \"def _frz(a):\\n if a.ndim == 0:\\n a.shape = (1,)\\n return a\",\n \"def _expand(x, ndim, axis=0):\\n while F.rank(x) < ndim:\\n x = F.expand_dims(x, axis)\\n return x\",\n \"def perturb(self, idx, axis=0, keep_changes=False):\\n \\n return self._method(idx, axis, keep_changes)\",\n \"def sliceForAxis(arr, axis=-1, start=None, stop=None, step=None):\\n\\n if (start is stop is step is None):\\n raise RuntimeError(\\\"``start``,``stop``, or ``step`` required!\\\")\\n\\n ndim = np.ndim(arr)\\n if (ndim == 0):\\n ndim = arr\\n\\n if (ndim > 1):\\n # Create an object to slice all elements of all dims\\n cut = [slice(None)]*ndim\\n # Exclude the last element of the last dimension\\n cut[axis] = slice(start, stop, step)\\n cut = tuple(cut)\\n else:\\n if (axis != 0) and (axis != -1):\\n raise RuntimeError(\\\"cannot slice nonexistent axis!\\\")\\n cut = slice(start, stop, step)\\n\\n return cut\",\n \"def identity( array ):\\n return _myarray.identity( array )\",\n \"def addem(inarr):\\n return np.expand_dims(inarr, axis=1)\",\n \"def autocorrelate(x):\\n\\n global i1, i2\\n # used for transposes\\n t = roll(range(x.ndim), 1)\\n\\n # pairs of indexes\\n # the first is for the autocorrelation array\\n # the second is the shift\\n ii = [list(enumerate(range(1, s - 1))) for s in x.shape]\\n\\n # initialize the resulting autocorrelation array\\n acor = empty(shape=[len(s0) for s0 in ii])\\n\\n # iterate over all combinations of directional shifts\\n for i in product(*ii):\\n # extract the indexes for\\n # the autocorrelation array\\n # and original array respectively\\n i1, i2 = asarray(i).T\\n\\n x1 = x.copy()\\n x2 = x.copy()\\n\\n for i0 in i2:\\n # clip the unshifted array at the end\\n x1 = x1[:-i0]\\n # and the shifted array at the beginning\\n x2 = x2[i0:]\\n\\n # prepare to do the same for\\n # the next axis\\n x1 = x1.transpose(t)\\n x2 = x2.transpose(t)\\n\\n # normalize shifted and unshifted arrays\\n x1 -= x1.mean()\\n x1 /= x1.std()\\n x2 -= x2.mean()\\n x2 /= x2.std()\\n\\n # compute the autocorrelation directly\\n # from the definition\\n acor[tuple(i1)] = (x1 * x2).mean()\\n\\n return acor\",\n \"def take_along_axis(a, indices, axis):\\n\\n if indices.dtype.kind not in ('i', 'u'):\\n raise IndexError('`indices` must be an integer array')\\n\\n if axis is None:\\n a = a.ravel()\\n axis = 0\\n\\n ndim = a.ndim\\n\\n axis = internal._normalize_axis_index(axis, ndim)\\n\\n if ndim != indices.ndim:\\n raise ValueError(\\n '`indices` and `a` must have the same number of dimensions')\\n\\n fancy_index = []\\n for i, n in enumerate(a.shape):\\n if i == axis:\\n fancy_index.append(indices)\\n else:\\n ind_shape = (1,) * i + (-1,) + (1,) * (ndim - i - 1)\\n fancy_index.append(cupy.arange(n).reshape(ind_shape))\\n\\n return a[tuple(fancy_index)]\",\n \"def strip_array_wrappers(arry):\\n curr = arry\\n if curr.ndim == 0:\\n if isinstance(curr[...], np.ndarray):\\n return strip_array_wrappers(curr[...])\\n return curr\\n\\n # there is a possibility for infinite looping\\n # e.g. [np.ndarray, str, dict] would stay object array\\n # impossible if homogeneous (implied by 1-element wrappers)\\n while isinstance(curr[0], np.ndarray):\\n if curr.shape[0] == 1:\\n curr = curr[0]\\n else:\\n curr = np.array(tuple(curr))\\n\\n return curr\",\n \"def collapse_dims(\\n arr: JaggedArray, axis: int = -1, inplace: bool = False\\n) -> JaggedArray:\\n\\n assert axis != 0, \\\"cannot collapse the zero'th axis\\\"\\n\\n if axis < 0:\\n axis += arr.ndim\\n\\n keepdims = np.delete(np.arange(arr.ndim), (axis - 1, axis - 2))\\n newshape = arr.shape[axis - 2] * arr.shape[axis - 1]\\n\\n if not keepdims.size:\\n shape = np.expand_dims(newshape, 0)\\n else:\\n shape = np.concatenate([arr.shape[: axis - 2], newshape], axis=1)\\n\\n if not inplace:\\n arr = arr.copy()\\n arr.shape = shape\\n return arr\",\n \"def permute(self, ordering: np.ndarray, *, axis: int) -> None:\\n\\t\\tif axis == 0:\\n\\t\\t\\tself.values = self.values[ordering, :]\\n\\t\\telif axis == 1:\\n\\t\\t\\tself.values = self.values[:, ordering]\\n\\t\\telse:\\n\\t\\t\\traise ValueError(\\\"axis must be 0 or 1\\\")\",\n \"def tilda_x(X):\\n return np.c_[np.ones(X.shape[0]), X]\",\n \"def shift(x, row_ind, col_ind, row_axis=0, col_axis=1, channel_axis=2,\\n fill_mode='constant', cval=0.):\\n h, w = x.shape[row_axis], x.shape[col_axis]\\n tx = row_ind - (h / 2)\\n ty = col_ind - (w / 2) \\n translation_matrix = np.array([[1, 0, tx],\\n [0, 1, ty],\\n [0, 0, 1]])\\n\\n transform_matrix = translation_matrix # no need to do offset\\n x = apply_transform(x, transform_matrix, channel_axis, fill_mode, cval)\\n \\n return x\",\n \"def rotate_along(axis: Tensor) -> Tensor:\\n W = torch.einsum('ijk,j->ik', levi_civita.to(axis), axis)\\n return expm(W)\",\n \"def convert_take_along_axis(g, op, block):\\n\\n x = g.get_node(op.input(\\\"Input\\\")[0])\\n idx = g.get_node(op.input(\\\"Index\\\")[0])\\n axis = op.attr(\\\"Axis\\\")\\n out = _op.gather(x, axis, idx)\\n g.add_node(op.output(\\\"Result\\\")[0], out)\",\n \"def put_along_axis(x1, indices, values, axis):\\n\\n x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)\\n indices_desc = dpnp.get_dpnp_descriptor(\\n indices, copy_when_nondefault_queue=False\\n )\\n values_desc = dpnp.get_dpnp_descriptor(\\n values, copy_when_nondefault_queue=False\\n )\\n if x1_desc and indices_desc and values_desc:\\n if x1_desc.ndim != indices_desc.ndim:\\n pass\\n elif not isinstance(axis, int):\\n pass\\n elif axis >= x1_desc.ndim:\\n pass\\n elif indices_desc.size != values_desc.size:\\n pass\\n else:\\n return dpnp_put_along_axis(x1_desc, indices_desc, values_desc, axis)\\n\\n return call_origin(\\n numpy.put_along_axis, x1, indices, values, axis, dpnp_inplace=True\\n )\",\n \"def apply(self, array: Tuple['Nparray']) -> 'FqeData':\\n\\n out = copy.deepcopy(self)\\n out.apply_inplace(array)\\n return out\",\n \"def test_direct_shape():\\n\\n n = 21\\n x = np.ones((n, n))\\n\\n recon = abel.direct.direct_transform(x, direction='forward')\\n assert recon.shape == (n, n) \\n\\n recon = abel.direct.direct_transform(x, direction='inverse')\\n assert recon.shape == (n, n)\",\n \"def flip(x, dim):\\n dim = x.dim() + dim if dim < 0 else dim\\n inds = tuple(slice(None, None) if i != dim\\n else x.new(torch.arange(x.size(i) - 1, -1, -1).tolist()).long()\\n for i in range(x.dim()))\\n return x[inds]\",\n \"def _roll_once(\\n tensor: tf.Tensor,\\n shift: int,\\n axis: int,\\n) -> tf.Tensor:\\n if not shift:\\n return tensor\\n axis = _normalize_axis(axis, len(tensor.shape))\\n slice_left = (slice(None),) * axis + (slice(-shift, None),)\\n slice_right = (slice(None),) * axis + (slice(None, -shift),)\\n return tf.concat([tensor[slice_left], tensor[slice_right]], axis=axis)\",\n \"def extract_into_tensor(arr, timesteps, broadcast_shape):\\n device = timesteps.device\\n assert arr.device == device\\n res = arr[timesteps].float()\\n new_dims = [1] * (len(broadcast_shape) - res.ndim)\\n res = res.view(*res.shape, *new_dims)\\n return torch.broadcast_to(res, broadcast_shape)\",\n \"def expand_dims_twice(array):\\n return np.expand_dims(np.expand_dims(array, axis=1), axis=1)\",\n \"def transform(x: np.array, params: TransformParams) -> np.array:\\n if params.do_hor_flip:\\n x = flip_axis(x, 1)\\n\\n if params.do_vert_flip:\\n x = flip_axis(x, 0)\\n\\n return x\",\n \"def wrap(array):\\n\\t\\t\\t\\n\\t\\t\\tassert array.ndim == 2, ('works on 2D arrays only; expecting '\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t 'self.cond_tuning, which should be 2D')\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\treturn np.column_stack((array, array[..., 0]))\",\n \"def index(x, axis, index_spec):\\n idx = [slice(None)] * x.ndim\\n idx[axis] = index_spec\\n\\n indexer = tuple(idx)\\n return indexer\",\n \"def __call__(self, axis=None):\\n # verify axis param, discard value\\n self._obj._is_sequence_axis(axis)\\n return self.__class__(self._obj, axis=axis)\",\n \"def reflection_pad2d(self, x, pad=1):\\n x = torch.cat([torch.flip(x[:, :, 1:pad + 1, :], [2]), x, torch.flip(x[:, :, -pad - 1:-1, :], [2])], 2)\\n x = torch.cat([torch.flip(x[:, :, :, 1:pad + 1], [3]), x, torch.flip(x[:, :, :, -pad - 1:-1], [3])], 3)\\n return x\",\n \"def naive_act_norm_initialize(x, axis):\\n x = np.asarray(x)\\n axis = list(sorted(set([a + len(x.shape) if a < 0 else a for a in axis])))\\n min_axis = np.min(axis)\\n reduce_axis = tuple(a for a in range(len(x.shape)) if a not in axis)\\n var_shape = [x.shape[a] for a in axis]\\n var_shape_aligned = [x.shape[a] if a in axis else 1\\n for a in range(min_axis, len(x.shape))]\\n mean = np.reshape(np.mean(x, axis=reduce_axis), var_shape)\\n bias = -mean\\n scale = 1. / np.reshape(\\n np.sqrt(np.mean((x - np.reshape(mean, var_shape_aligned)) ** 2,\\n axis=reduce_axis)),\\n var_shape\\n )\\n return scale, bias, var_shape_aligned\",\n \"def flatten(self, arr):\\n shape = arr.shape\\n return arr.reshape(shape[0] * shape[1], *shape[2:])\",\n \"def standardize_single_array(x):\\n if x is None:\\n return None\\n if tensor_util.is_tensor(x):\\n x_shape_ndims = array_ops.rank(x)\\n else:\\n x_shape_ndims = len(x.shape)\\n\\n if (x_shape_ndims == 1 and (expected_shape is None or len(expected_shape) != 1)):\\n if tensor_util.is_tensor(x):\\n x = array_ops.expand_dims(x, axis=1)\\n else:\\n x = np.expand_dims(x, 1)\\n return x\",\n \"def matricize(X, axis):\\n # If negative axis is passed, convert to equivalent positive form\\n if axis < 0:\\n axis = X.ndim + axis\\n # Need to transpose so that ordering is correct\\n # X.shape = (7, 3, 11)\\n # matricize(X, 0).shape = (7, 11 * 3)\\n # matricize(X, 1).shape = (3, 11 * 7)\\n # matricize(X, 2).shape = (11, 3 * 7)\\n # Long term, may need an option to specify whether to reverse or not\\n not_axis = np.where(np.arange(X.ndim) != axis)[0][::-1]\\n return X.transpose(axis, *not_axis).reshape(X.shape[axis], -1)\",\n \"def observation(self, obs):\\n\\n# import pdb;pdb.set_trace()\\n return np.moveaxis(obs, 2, 0)\",\n \"def transpose_inplace(x, **kwargs):\\r\\n dims = range(x.ndim-1, -1, -1)\\r\\n return elemwise.DimShuffle(x.broadcastable, dims, inplace=True)(x)\",\n \"def getslice(arr: tf.Tensor, slice: tf.Tensor, axis: int) -> tf.Tensor:\\n if arr is None:\\n return None\\n return tf.boolean_mask(arr, slice, axis=axis)\",\n \"def __get_transformed_axis__(data, c, x):\\n dx = data[c]\\n dx -= x[0]\\n dx /= x[-1] - x[0]\\n dx *= x.shape[0]\\n dx = np.round(x)\\n return np.int32(dx)\",\n \"def nonzero_last(arr, *, axis):\\n def nonzero_last_1d(arr):\\n try:\\n return np.nonzero(arr)[0][-1]\\n except IndexError:\\n return -1\\n return np.apply_along_axis(nonzero_last_1d, axis, arr)\",\n \"def fliplr(a):\\n if a.ndim < 2:\\n raise ValueError('Input must be >= 2-d')\\n return a[::, ::-1]\",\n \"def unfold_axis(data, k):\\n\\n target_dim = k\\n total_dim = len(data.shape)\\n\\n dim_list = []\\n for i in range(total_dim):\\n dim_list.append((target_dim - i) % total_dim)\\n dim_order = tuple(dim_list)\\n\\n data_unfold = np.transpose(data,dim_order)\\n data_unfold = np.reshape(data_unfold,[data.shape[k],int(data.size/data.shape[k])])\\n return data_unfold\",\n \"def velocity_interpolation(a, axis=-1):\\n nd = len(a.shape)\\n\\n # adding one extra dimension to field at the lower boundary with\\n # zeros.\\n a_shape = list(a.shape)\\n a_shape[axis] = a.shape[axis] + 1\\n a_shape = tuple(a_shape)\\n slice0 = [slice(None)] * nd\\n slice0[axis] = slice(1, None)\\n slice0 = tuple(slice0)\\n a_prim = np.zeros(a_shape)\\n a_prim[slice0] = a\\n\\n # doing the interpolation\\n slice1 = [slice(None)] * nd\\n slice2 = [slice(None)] * nd\\n slice1[axis] = slice(None, -1)\\n slice2[axis] = slice(1, None)\\n slice1 = tuple(slice1)\\n slice2 = tuple(slice2)\\n\\n a_interp = (a_prim[slice1] + a_prim[slice2])/2\\n return a_interp\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67617947","0.6650867","0.61850905","0.6083956","0.5720959","0.57025504","0.5559801","0.5524613","0.55142355","0.54787475","0.5478125","0.5472565","0.54558724","0.5451142","0.53963137","0.53875583","0.5342568","0.5339039","0.5313937","0.53026325","0.53007036","0.5296241","0.5296241","0.5296241","0.5296241","0.529301","0.5286551","0.5275018","0.52291626","0.5220617","0.5220204","0.5206844","0.5189119","0.5150171","0.5147844","0.5138614","0.51269543","0.5121301","0.51180637","0.51094663","0.510902","0.51089746","0.5089709","0.50782317","0.50586957","0.50561357","0.50561357","0.5054519","0.5051258","0.5043102","0.50333905","0.5029646","0.50270844","0.5023462","0.50203264","0.5018753","0.50109756","0.50047004","0.5001599","0.5001599","0.49959666","0.49681786","0.49563166","0.49554995","0.49541727","0.49451897","0.49433556","0.49416357","0.49253127","0.49242207","0.4919543","0.491589","0.49107352","0.4903591","0.4902161","0.48887056","0.48882207","0.48881194","0.4880915","0.48697206","0.48641244","0.48588327","0.48574477","0.48537707","0.48453763","0.48363537","0.48322356","0.48229074","0.4804737","0.47976586","0.47931257","0.47886005","0.4788204","0.47879142","0.47847968","0.478224","0.4777147","0.47753176","0.47749507","0.47716165"],"string":"[\n \"0.67617947\",\n \"0.6650867\",\n \"0.61850905\",\n \"0.6083956\",\n \"0.5720959\",\n \"0.57025504\",\n \"0.5559801\",\n \"0.5524613\",\n \"0.55142355\",\n \"0.54787475\",\n \"0.5478125\",\n \"0.5472565\",\n \"0.54558724\",\n \"0.5451142\",\n \"0.53963137\",\n \"0.53875583\",\n \"0.5342568\",\n \"0.5339039\",\n \"0.5313937\",\n \"0.53026325\",\n \"0.53007036\",\n \"0.5296241\",\n \"0.5296241\",\n \"0.5296241\",\n \"0.5296241\",\n \"0.529301\",\n \"0.5286551\",\n \"0.5275018\",\n \"0.52291626\",\n \"0.5220617\",\n \"0.5220204\",\n \"0.5206844\",\n \"0.5189119\",\n \"0.5150171\",\n \"0.5147844\",\n \"0.5138614\",\n \"0.51269543\",\n \"0.5121301\",\n \"0.51180637\",\n \"0.51094663\",\n \"0.510902\",\n \"0.51089746\",\n \"0.5089709\",\n \"0.50782317\",\n \"0.50586957\",\n \"0.50561357\",\n \"0.50561357\",\n \"0.5054519\",\n \"0.5051258\",\n \"0.5043102\",\n \"0.50333905\",\n \"0.5029646\",\n \"0.50270844\",\n \"0.5023462\",\n \"0.50203264\",\n \"0.5018753\",\n \"0.50109756\",\n \"0.50047004\",\n \"0.5001599\",\n \"0.5001599\",\n \"0.49959666\",\n \"0.49681786\",\n \"0.49563166\",\n \"0.49554995\",\n \"0.49541727\",\n \"0.49451897\",\n \"0.49433556\",\n \"0.49416357\",\n \"0.49253127\",\n \"0.49242207\",\n \"0.4919543\",\n \"0.491589\",\n \"0.49107352\",\n \"0.4903591\",\n \"0.4902161\",\n \"0.48887056\",\n \"0.48882207\",\n \"0.48881194\",\n \"0.4880915\",\n \"0.48697206\",\n \"0.48641244\",\n \"0.48588327\",\n \"0.48574477\",\n \"0.48537707\",\n \"0.48453763\",\n \"0.48363537\",\n \"0.48322356\",\n \"0.48229074\",\n \"0.4804737\",\n \"0.47976586\",\n \"0.47931257\",\n \"0.47886005\",\n \"0.4788204\",\n \"0.47879142\",\n \"0.47847968\",\n \"0.478224\",\n \"0.4777147\",\n \"0.47753176\",\n \"0.47749507\",\n \"0.47716165\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69821197"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":24586,"cells":{"query":{"kind":"string","value":"Return some points from a 2d lattice (with the origin first)."},"document":{"kind":"string","value":"def make_lattice(min,max,lattice_vectors):\n xs = np.roll(np.arange(min[0],max[0]),max[0])\n ys = np.roll(np.arange(min[1],max[1]),max[1])\n lattice = np.dstack(np.meshgrid(xs,ys)).reshape(-1,2)\n lattice = np.matmul(lattice,lattice_vectors)\n return lattice"},"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 getLatticePoints():\n latticePoints = []\n\n for y in arange(yMin, yMax + yStep, yStep):\n for x in arange(xMin, xMax + xStep, xStep):\n latticePoints.append(LatticePoint(x, y))\n\n \n return latticePoints","def get_lattice_points(self) -> List[np.ndarray]:\n lattice_points = []\n for factor in self.get_all_factors():\n lp = cast_integer_matrix(np.dot(self.left_inv, factor))\n lattice_points.append(lp)\n return lattice_points","def get_points(self):\r\n return self.nx*self.ny*self.nz","def make_xy(N, origin=None):\r\n if type(N) == int :\r\n ny, nx = N, N\r\n elif len(N) == 2 :\r\n ny, nx = N \r\n elif len(N) == 1 and (type(N) == tuple or type(N) == list):\r\n ny = N[0] \r\n nx = 0\r\n if ny != 0 and nx != 0 :\r\n x, y = np.meshgrid(np.arange(nx), np.arange(ny))\r\n if (origin is None) or (origin == 'centre') :\r\n origin_x, origin_y = nx // 2 - 1, ny // 2 - 1\r\n x -= origin_x\r\n y -= origin_y\r\n elif origin[0] == 0 and (origin[1] == 0):\r\n x = ((x + nx // 2 - 1) % nx) - (nx // 2 - 1)\r\n y = ((y + ny // 2 - 1) % ny) - (ny // 2 - 1)\r\n return x, y\r\n elif ny != 0 and nx == 0 :\r\n y = np.arange(ny)\r\n if (origin is None) or (origin == 'centre') :\r\n origin_y = ny // 2 - 1\r\n y -= origin_y\r\n elif origin[0] == 0 :\r\n y = ((y + ny // 2 - 1) % ny) - (ny // 2 - 1)\r\n return y","def lattice_coords(cutoffs):\n Nx = cutoffs[0]\n Ny = cutoffs[1]\n Nz = cutoffs[2]\n \n return np.array([np.kron(np.arange(-Nx,Nx+1, dtype = int), np.kron(np.ones(2*Ny+1,dtype = int), np.ones(2*Nz+1, dtype = int)) ),\n np.kron(np.ones(2*Nx+1, dtype = int), np.kron(np.arange(-Ny,Ny+1, dtype = int), np.ones(2*Nz+1, dtype = int)) ),\n np.kron(np.ones(2*Nx+1, dtype = int), np.kron(np.ones(2*Ny+1, dtype = int), np.arange(-Nz, Nz+1, dtype = int)) )]).T","def lattice(self):\n return self._lattice","def __getxy(x1, y1, x2, y2):\n\t\treturn x1*27+y1*9+x2*3+y2","def get_xy(self, x, y):\r\n\t\treturn self.grid[y, x]","def latlon_2_grid(x, y, z, origin):\n new_y = (y - origin[1]) * 111111\n new_x = (x - origin[0]) * (111111 * np.cos(origin[1] * (np.pi/180)))\n return new_x, new_y, z","def xy(self):\n return self.to_xyah()[0:2]","def xyxy(x, y, hd1, hd2):\n wcs1 = wcs.WCS(hd1)\n wcs2 = wcs.WCS(hd2)\n ra, dec = wcs1.all_pix2world(x, y, 1)\n x2, y2 = wcs2.all_world2pix(ra, dec, 1)\n return x2, y2","def get_xy_grid(nx, ny):\n\tfor n in [nx, ny]:\n\t\tif not isodd(n):\n\t\t\traise Exception(\"[get_xy_grid] only accept odd number\")\n\n\tx, y = np.mgrid[-(nx-1)/2:(nx+1)/2, -(ny-1)/2:(ny+1)/2]\n\n\treturn x, y","def obtain_points(self):\n # Swapaxes makes the output a column rather than a row\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"GridCoordinates\"][\"CoordinateX\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"GridCoordinates\"][\"CoordinateY\"][\" data\"][:, :, :]),\n np.ndarray.flatten(self.data[\"Base\"][\"Zone1\"][\"GridCoordinates\"][\"CoordinateZ\"][\" data\"][:, :, :])]), 0, 1)","def coordinate_in_lattice(v,n,m):\n y=int(v/n);\n x=(v%n);\n\n return (x,y)","def _get_xy_lims(self):\n \n x = self.datapos[0] - 1\n y = self.datapos[1] - 1\n\n return x, y","def get_cells(pts, inv_cell_width, Ny, Nx, log=sys.stdout):\n lib = _initlib()\n p = require(pts, dtype=float64, requirements=['C']) \n npts = p.shape[0]\n assert(p.shape ==(npts,3))\n out = empty(npts, dtype=int64)\n\n res = lib.find_lattice(p, npts, inv_cell_width, Ny, Nx, out)\n return out","def origin():\n\n # indices: [axis, point]\n return numpy.zeros((3, 1))","def coords2D(self):\n return (self.x, self.y)","def xy(self):\n xcol = self.xx.reshape(-1, 1)\n ycol = self.yy.reshape(-1, 1)\n return np.column_stack([xcol, ycol])","def xy(self) -> Tuple[float, float]:\n return (self.x, self.y)","def xy_coordinates(self):\n\n return np.meshgrid(self.x_coord, self.y_coord)","def _xy_locs(mask):\n y, x = mask.nonzero()\n return list(zip(x, y))","def lattice_pos(npart,r,box):\n\n #Calculo cantidad de celdas por lado\n n = int(np.ceil(np.sqrt(npart)))\n \n #calculo el centro de la celda\n nf = 1.0/float(n)\n \n #Calculo las posiciones de todas las celdas disponibles agregando un r% de randomizacion\n \n celdas = [[i*nf +0.5*nf + r*np.random.uniform(low=-box/2,high=box/2),j*nf + 0.5*nf+ r*np.random.uniform(low=-box/2,high=box/2),k*nf + 0.5*nf+ r*np.random.uniform(low=-box/2,high=box/2)]\n for i in range(n) for j in range(n) for k in range(n)]\n \n #Mezclo las posiciones de las celdas\n np.random.shuffle(celdas)\n \n X = np.array(celdas[0:npart])\n return X","def _getitem_2d(self, pos):\n if isinstance(pos, list):\n if isinstance(pos[0], (int, np.integer)): # single point\n return self[pos[0], pos[1]]\n else:\n return [self[p] for p in pos]\n elif isinstance(pos, np.ndarray):\n if isinstance(pos[0], (int, np.integer)): # single point\n return np.array(self[pos[0], pos[1]])\n else:\n return np.array([self[p] for p in pos])\n # compute coordinates from OneDimGrids of its master.\n x = self.master.x[pos[0]]\n y = self.master.y[pos[1]]\n # TODO: Refactor the following code to avoid the use of double for loops and list comprehensions.\n if (not isinstance(x, np.ndarray)) and (not isinstance(y, np.ndarray)): # x and y are scalars.\n return np.array([x, y])\n if not isinstance(x, np.ndarray): # x is a scalar.\n return np.array([np.array([x, _y]) for _y in y])\n elif not isinstance(y, np.ndarray): # y is a scalar.\n return np.array([np.array([_x, y]) for _x in x])\n else:\n xy = []\n for _x in x: # vectorize this operation.\n row = []\n for _y in y:\n row.append(np.array([_x, _y]))\n xy.append(np.array(row))\n return np.array(xy)","def _gather_points(self):\n # This is just a stub for now. We should really find the lines only\n # inside the screen range here.\n\n x = self.index.get_data()\n y = self.value.get_data()\n rad= min(self.width/2.0,self.height/2.0)\n sx = x*rad+ self.x + self.width/2.0\n sy = y*rad+ self.y + self.height/2.0\n\n points = transpose(array((sx,sy)))\n self._cached_data_pts = points\n self._cache_valid = True\n return","def get_neighbors(point):\n pt = point.copy()\n output= [point.copy() for i in range(4)]\n output[0:2] = map(Point.setY, output[0:2], [pt.getY()+ i for i in range(-1,2,2)])\n output[2:4]= map(Point.setX, output[2:4], [pt.getX()+ i for i in range(-1,2,2)])\n return output","def xy(self) -> Tuple[int, int]:\n return self._x, self._y","def points(self, ntheta, nlayer):\n exec self.x\n exec self.y\n return [x, y]","def afficher_points_2D(set_points):\n X, Y = [p[0][0] for p in set_points], [p[0][1] for p in set_points]\n return(X, Y)","def lattice(image, res=20):\n\tH, W = image.shape[0], image.shape[1]\n\txs = np.linspace(0, W, res).astype(np.uint16)\n\tys = np.linspace(0, H, res).astype(np.uint16)\n\tpts = []\n\tfor x in xs:\n\t\tfor y in ys:\n\t\t\tpts.append((x,y))\n\treturn pts","def get_random_coordinates(self):\n array_shape = np.shape(self.cells) # type: tuple\n points_on_island = []\n for i in range(1, array_shape[0] - 1):\n for j in range(1, array_shape[1] - 1):\n points_on_island.append((i, j))\n random.shuffle(points_on_island)\n return points_on_island","def p2p_xyz(start_point, end_point, top_left_cor, cellsize, dem):\n start_cell = (int((start_point[0] - top_left_cor[0]) / cellsize[0]),\n int((start_point[1] - top_left_cor[1]) / cellsize[1]))\n end_cell = (int((end_point[0] - top_left_cor[0]) / cellsize[0]),\n int((end_point[1] - top_left_cor[1]) / cellsize[1]))\n cells = misc.get_line(start_cell, end_cell) \n pnts = []\n elev = []\n \n dem_elv = dem[:,1]\n dem_indx = dem[:,2:4]\n\n for cell in cells:\n x = top_left_cor[0] + cell[0] * cellsize[0] + cellsize[0] / 2\n y = top_left_cor[1] + cell[1] * cellsize[1] + cellsize[1] / 2\n #xy_indx=[str(cell[0]),str(cell[1])]\n z_indx=np.logical_and(np.equal(dem_indx[:,0],cell[0]),np.equal(dem_indx[:,1],cell[1]))\n try:\n z=dem_elv[z_indx][0]\n except (np.sum(z_indx)>1):\n print(\"Oops! That was more than one indices in dem matching the query index (in getCellValue)\")\n #z_indx = [i for i,j in enumerate(dem_indx) if j == xy_indx]\n z = float(dem_elv[z_indx])\n pnts.append((x, y))\n elev.append(z)\n return pnts, elev","def _generate_coords(self):\n coords = np.dstack([self.X.ravel(), self.Y.ravel()])[0]\n return coords, spatial.cKDTree(coords)","def getxySorted(self):\n from operator import itemgetter\n x,y=self.getxy()\n s=sorted(zip(x,y), key=itemgetter(0))\n x,y = zip(*s)\n return x,y","def getXY(self):\n return (self.X,self.Y)","def xy(self):\n return self.coords.xy","def positions(r):\n\n X = []\n Y = []\n\n leftx = -r*(nx - 1) / 2\n topy = -r*(ny - 1) / 2\n\n for i in range(0, nx):\n for j in range(0, ny):\n X.append(leftx + r * i)\n Y.append(topy + r * j)\n\n return (X, Y)","def generate_L_shaped_domain(nx, ny, Lx1,Lx2,Ly1,Ly2):\n X1,Y1=generate_square_domain(x_min=0, x_max=Lx2, y_min=0, y_max=Ly1,\\\n nx=nx, ny=np.floor(ny/2))\n X2,Y2=generate_square_domain(x_min=0, x_max=Lx1, y_min=Ly1, y_max=Ly2,\\\n nx=np.floor(nx/2), ny=ny)\n return [[X1, Y1], [X2,Y2]]","def ipset_x_2d():\n x1 = np.linspace(0, 10, 11)\n x2 = np.linspace(-3, 3, 11)\n return IPSet(x=np.stack((x1, x2), axis=1), y=np.linspace(-1, 1, 11), x_new=np.stack((x1[1:-1], x2[1:-1]), axis=1))","def point(self):\n bfsize = card(self.basefield)\n one = self.basefield.one\n t = self.basefield.zero\n if len(self) == 2 or (self.a1 == self.a2 == self.a3 == self.basefield.zero):\n while self.basefield.Legendre(t) != 1:\n s = self.basefield.createElement(bigrandom.randrange(bfsize))\n t = self.cubic(s)\n if not t:\n return [s, t]\n t = self.basefield.sqrt(t)\n r = bigrandom.randrange(2)\n if r:\n return [s, -t]\n return [s, t]\n elif self.ch != 2 and self.ch != 3:\n sform = self.simple()\n while sform.basefield.Legendre(t) != 1:\n s = sform.basefield.createElement(bigrandom.randrange(bfsize))\n t = (s**3+sform.a*s+sform.b)\n x = (s-3*self.b2) // (36*one)\n y = (sform.basefield.sqrt(t) // (108*one)-self.a1*x-self.a3)//(2*one)\n return [x, y]\n elif self.ch == 3:\n while sform.basefield.Legendre(t) != 1:\n s = self.basefield.createElement(bigrandom.randrange(bfsize))\n t = (s**3+self.a2*s**2+self.a4*s+self.a6)\n return [s, self.basefield.sqrt(t)]\n else:\n raise NotImplementedError(\"This is not implemented.\")","def _build_point_grid(n_per_side: int) -> np.ndarray:\n offset = 1 / (2 * n_per_side)\n points_one_side = np.linspace(offset, 1 - offset, n_per_side)\n points_x = np.tile(points_one_side[None, :], (n_per_side, 1))\n points_y = np.tile(points_one_side[:, None], (1, n_per_side))\n points = np.stack([points_x, points_y], axis=-1).reshape(-1, 2)\n return points","def render_points_2d(self, **kwds):\n return point2d(self.coordinates_of(self.points), **kwds)","def getCoords(self): # real signature unknown; restored from __doc__\r\n pass","def get_traj_point(box):\n x1, _, x2, y2 = box\n return [(x1 + x2) / 2.0, y2]","def get_xy(ncenters, ndim, rstate):\n flag = True\n while flag:\n buff = 10 * ncenters\n args = [buff,ndim]\n randxy = rstate.rand(*args)*2 - 1. # Multi-dimensional array of -1 to 1 values\n # Generate Radius**2\n radius2 = np.sum(randxy**2,1)\n # Grab the good ones\n gdr2 = np.where(radius2 < 1.)[0]\n # Check we have enough\n if len(gdr2) > ncenters:\n flag = False\n # Return the first ncenters\n return randxy[gdr2[0:ncenters],:]","def ystagg_xy_coordinates(self):\n\n x = self.center_grid.x0 + np.arange(self.nx) * self.dx\n y_s = self.corner_grid.y0 + np.arange(self.ny+1) * self.dy\n return np.meshgrid(x, y_s)","def xyz(self, i):\n return self.xp[i], self.yp[i], self.zp[i]","def points(self):\n return np.vstack((self.x(), self.y()))","def get_base_coords(self):\n num_bases = len(self.tour)\n base_coords = np.zeros((num_bases,3), dtype=float)\n for i,base in enumerate(self.tour):\n helix_num = base.h\n helix_pos = base.p\n helix = self.helix_list[helix_num]\n base_coords[i] = base.coordinates\n return base_coords","def grid_coords(self):\n return [(x, y) for y in range(self.height) for x in range(self.width)]","def sub2xy(self, ix, iy):\n x = self.Lx * (ix + .5)/self.Nx\n y = self.Ly * (iy + .5)/self.Ny\n return x, y","def get_minnpix(self, pixel_size, radius):\n\n npix = latticepoints(radius,pixel_size)\n return npix","def GetParametricCoords(self):\n ...","def get_gridinfo(filename, xpoints, ypoints):\n with open(f\"{filename[:-4]}.wld\", encoding=\"ascii\") as fh:\n lines = fh.readlines()\n dx = float(lines[0])\n dy = float(lines[3])\n west = float(lines[4])\n north = float(lines[5])\n south = north + dy * ypoints\n lats = np.arange(0, ypoints) * (0 - dy) + south\n lons = np.arange(0, xpoints) * dx + west\n return lons, lats","def _get_grid_coord(self, point):\n return tuple([int(point[i] / self._cell_length) for i in range(self._dim)])","def _get_pt_tuple(pnt1, pnt2):\n return tuple(map(_map_x_dim(tuple(pnt1)), pnt2))","def ricomLocal2LL(points,lat0=0,long0=0,latoff=0,longoff=0): \n import math\n bigr = 6378136.0\n dlong = longoff-long0\n dlat = latoff-lat0\n clat0 = math.cos(lat0*math.pi/180.0)\n numPts = len(points)\n n = 0\n pointsLL=[]\n while n<numPts:\n x = points[n][0]/(bigr*(math.pi/180.0)*clat0) - dlong\n y = points[n][1]/(bigr*(math.pi/180.0)) - dlat\n pointsLL.append([x,y])\n n+=1\n \n return pointsLL","def candidate_start_points_lattice(bounds, nums=3):\n\n if isinstance(nums, int):\n nums = repeat(nums)\n\n linspaces = [np.linspace(start, end, num) for (start, end), num\n in zip(bounds, nums)]\n return np.vstack(a.flatten() for a in np.meshgrid(*linspaces))","def getCoord(self, i):\n _x = self.__xpts[i]\n _y = self.__ypts[i]\n return _x, _y","def get_point_on(self, s):\n\n x = self.n1.x * (1 - s) + self.n2.x * s\n y = self.n1.y * (1 - s) + self.n2.y * s\n z = self.n1.z * (1 - s) + self.n2.z * s\n\n return [x, y, z]","def points(self):\n p = []\n for v in self.iter():\n p.append((v.x, v.y))\n return p","def point_location(tri, p): \n simplex_index = tri.find_simplex(p)\n bc = []\n for id_, point in zip(simplex_index, p):\n # Calculate the two first barycentric coordinates for the relevant\n # simplex\n b = tri.transform[id_, :2].dot(point-tri.transform[id_, 2])\n bc.append(np.c_[np.atleast_2d(b), 1-b.sum()])\n # Create the full array and squeeze the shit out of it\n bc = np.array(bc).squeeze()\n return simplex_index, bc","def _get_xy_coords(self, exterior, coord_type):\n if coord_type == 'x':\n return exterior.coords.xy[0]\n elif coord_type == 'y':\n return exterior.coords.xy[1]","def __init__(self, lattice, lp, xytup=None, NL=None, KL=None, PVx=None, PVy=None,\n BL_nm=None, NL_nm=None, KL_nm=None,\n Omg=None, OmK=None, matrix=None, eigval=None, eigvect=None, eps=1e-8, overwrite=False):\n # xytup is a tuple of inner points, outer points. Define self.xy to be all sites, including immobile ones\n self.lattice = lattice\n # lp contains Omg, Omk, als. With weights, Omg = 1.5, otherwise Omg = 1.0\n # Omk = k_m l^2 / I omega -> 0.86 in original experiments\n # aoverl = 0.0305/.038\n self.lp = lp\n self.inner_indices = None\n self.outer_indices = None\n\n if xytup is None:\n # Create self.xy and self.xy_inner\n self.xy = lattice.xy\n if 'roi' in self.lp:\n self.xy_inner = le.pts_in_polygon(self.xy, self.lp['roi'])\n else:\n # get boundary of the lattice and denote these particles as the outer particles\n # boundary = le.extract_boundary(self.xy, self.lattice.NL, self.lattice.KL, self.lattice.BL,\n # check=False)\n boundary = self.lattice.get_boundary()\n if boundary is None:\n self.xy_inner = self.xy\n elif isinstance(boundary, tuple):\n # There are multiple boundaries. Exclude all of them from inner_indices\n inners = np.arange(len(self.xy))\n outers = []\n for bndy in boundary:\n inners = np.setdiff1d(inners, np.array(bndy))\n outers.append(bndy)\n\n self.inner_indices = np.hstack(inners)\n self.outer_indices = np.hstack(outers)\n self.xy_inner = self.xy[self.inner_indices]\n else:\n self.inner_indices = np.setdiff1d(np.arange(len(self.xy)), np.array(boundary))\n self.outer_indices = np.array(boundary)\n self.xy_inner = self.xy[self.inner_indices]\n else:\n self.xy = xytup[1]\n self.xy_inner = xytup[0]\n\n if NL is not None and KL is not None:\n self.NL = NL\n self.KL = KL\n # determine if shortrange or longrange or intermediate interaction_range from supplied NL\n # if lp['intrange'] == 1:\n # nl_meshfn_exten = '_shortrange'\n if lp['intrange'] > 0:\n nl_meshfn_exten = '_intrange{0:04d}'.format(mglat.lp['interaction_range'])\n else:\n nl_meshfn_exten = ''\n # Get PVxy if not supplied\n if PVx is not None and PVy is not None:\n self.PVx, self.PVy = PVx, PVy\n else:\n if (KL > -eps).all():\n self.PVx = np.zeros_like(NL, dtype=float)\n self.PVy = np.zeros_like(NL, dtype=float)\n else:\n raise RuntimeError('periodic KL is supplied, but PVx and PVy are not supplied')\n else:\n self.NL, self.KL, self.PVx, self.PVy, nl_meshfn_exten = mgfns.create_NL_KL_pv(self)\n\n # print 'self.xy_inner = ', np.shape(self.xy_inner)\n # print 'self.xy = ', np.shape(self.xy)\n if self.inner_indices is None or self.outer_indices is None:\n self.outer_indices, self.inner_indices, self.total2inner = self.outer_inner(self.xy, self.xy_inner)\n\n # Add lattice properties to gyro_lattice_properties, by convention, but don't overwrite params\n for key in self.lattice.lp:\n if key not in self.lp:\n self.lp[key] = self.lattice.lp[key]\n\n ########################################################################\n self.lp['meshfn_exten'] = '_magnetic' + nl_meshfn_exten + '_aol' + sf.float2pstr(self.lp['aoverl'])\n # For magnetic class, OmK is bond dependent: OmK = 3 mu_0 M^2/ (pi a^5) for each bond\n if self.lp['Omk'] != -1.0:\n self.lp['meshfn_exten'] += '_Omk' + sf.float2pstr(self.lp['Omk'])\n\n # Build OmK array for couplings\n self.OmK, lp_Omk, omk_meshfn_exten = mgfns.build_OmK(self, self.lp, None)\n\n # Form Omg\n if Omg == 'auto' or Omg is None:\n if 'Omg' in self.lp:\n self.Omg = self.lp['Omg'] * np.ones_like(self.xy_inner[:, 0])\n else:\n print 'giving Omg the default value of -1s...'\n self.Omg = -1.0 * np.ones_like(self.xy_inner[:, 0])\n if self.lp['Omg'] != -1.0:\n self.lp['meshfn_exten'] += '_Omg' + sf.float2pstr(self.lp['Omg'])\n else:\n self.Omg = Omg\n if 'Omg' in self.lp:\n if (self.Omg != self.lp['Omg'] * np.ones(np.shape(self.xy_inner)[0])).any():\n self.lp['meshfn_exten'] += '_Omgspec'\n self.lp['Omg'] = -5000\n else:\n # Check if the values of all elements are identical\n kinds = np.nonzero(self.Omg)\n if len(kinds[0]) > 0:\n # There are some nonzero elements in Omg. Check if all the same\n value = self.Omg[kinds[0]]\n if (Omg[kinds] == value).all():\n self.lp['Omg'] = value\n else:\n self.lp['Omg'] = -5000\n else:\n self.lp['Omg'] = 0.0\n if 'ABDelta' in self.lp:\n if np.abs(self.lp['ABDelta']) > eps:\n self.lp['meshfn_exten'] += '_ABd{0:0.3f}'.format(self.lp['ABDelta']).replace('.', 'p').replace('-', 'n')\n else:\n self.lp['ABDelta'] = 0.\n\n # First check for gaussian disorder\n if 'V0_pin_gauss' in self.lp and 'V0_spring_gauss' in self.lp:\n if abs(self.lp['V0_pin_gauss']) > eps or (self.lp['V0_spring_gauss']) > eps:\n self.lp['dcdisorder'] = True\n self.lp['meshfn_exten'] += '_pinV' + sf.float2pstr(self.lp['V0_pin_gauss'])\n self.lp['meshfn_exten'] += '_sprV' + sf.float2pstr(self.lp['V0_spring_gauss'])\n if 'pinconf' not in self.lp:\n self.lp['pinconf'] = 0\n elif self.lp['pinconf'] > 0:\n self.lp['meshfn_exten'] += '_conf{0:04d}'.format(self.lp['pinconf'])\n else:\n self.lp['dcdisorder'] = False\n\n # If no gaussian disorder check for flat disorder\n if 'V0_pin_flat' in self.lp and 'V0_spring_flat' in self.lp and not self.lp['dcdisorder']:\n if abs(self.lp['V0_pin_flat']) > eps or (self.lp['V0_spring_flat']) > eps:\n self.lp['dcdisorder'] = True\n self.lp['meshfn_exten'] += '_pinVflat' + sf.float2pstr(self.lp['V0_pin_flat'])\n self.lp['meshfn_exten'] += '_sprVflat' + sf.float2pstr(self.lp['V0_spring_flat'])\n if 'pinconf' not in self.lp:\n self.lp['pinconf'] = 0\n elif self.lp['pinconf'] > 0:\n self.lp['meshfn_exten'] += '_conf{0:04d}'.format(self.lp['pinconf'])\n else:\n self.lp['dcdisorder'] = False\n\n # If neither gaussian nor flat, input no disorder\n if not self.lp['dcdisorder']:\n self.lp['V0_pin_gauss'] = 0.\n self.lp['V0_spring_gauss'] = 0.\n self.lp['V0_pin_flat'] = 0.\n self.lp['V0_spring_flat'] = 0.\n self.lp['pinconf'] = 0\n self.lp['dcdisorder'] = False\n\n vpin_has_gaussian = self.lp['V0_pin_gauss'] > eps or self.lp['V0_spring_gauss'] > eps\n vpin_has_flat = self.lp['V0_pin_flat'] > eps or self.lp['V0_spring_flat'] > eps\n if abs(self.lp['ABDelta']) > eps or vpin_has_gaussian or vpin_has_flat:\n # In order to load the random (V0) or alternating (AB) pinning sites, look for a txt file with the pinnings\n # that also has specifications in its meshfn exten, but IGNORE other parts of meshfnexten, if they exist.\n # Form abbreviated meshfn exten\n pinmfe = self.get_pinmeshfn_exten()\n\n print 'Trying to load offset/disorder to pinning frequencies: '\n print dio.prepdir(self.lp['meshfn']) + pinmfe\n # Attempt to load from file\n if not overwrite:\n try:\n self.load_pinning(meshfn=self.lp['meshfn'])\n # self.Omg = np.loadtxt(dio.prepdir(self.lp['meshfn']) + pinmfe + '.txt')\n # raise RuntimeError('This means an erronous Omg was saved --where was it saved?')\n print 'Loaded ABDelta and/or dcdisordered pinning frequencies.'\n define_Omg_now = False\n except IOError:\n define_Omg_now = True\n else:\n define_Omg_now = True\n\n if define_Omg_now:\n print 'Could not load ABDelta and/or dcdisordered pinning frequencies, defining them here...'\n # Make Omg from scratch\n if abs(self.lp['ABDelta']) > eps:\n asites, bsites = glatfns.ascribe_absites(self.lattice)\n self.Omg[asites[self.inner_indices]] += self.lp['ABDelta']\n self.Omg[bsites[self.inner_indices]] -= self.lp['ABDelta']\n if vpin_has_flat or vpin_has_gaussian:\n self.add_dcdisorder()\n\n # Save non-standard Omg\n if 'save_pinning_to_hdf5' in self.lp:\n if self.lp['save_pinning_to_hdf5']:\n force_hdf5pin = True\n else:\n force_hdf5pin = False\n else:\n force_hdf5pin = False\n self.save_Omg(infodir=self.lp['meshfn'], histogram=False, force_hdf5=force_hdf5pin, overwrite=overwrite)\n # self.plot_Omg()\n # np.savetxt(dio.prepdir(self.lp['meshfn']) + pinmfe + '.txt', self.Omg)\n # self.plot_Omg()\n\n ########################################################################\n\n # Non magnetic --> nm: taken from lat.NL, lat.KL, these are the inner particles (xy_in) connectivity M x M\n if BL_nm is not None:\n self.BL_nm = BL_nm\n if NL_nm is not None and KL_nm is not None:\n self.NL_nm = NL_nm\n self.KL_nm = KL_nm\n else:\n self.NL_nm, self.KL_nm = le.BL2NLandKL(self.BL_nm)\n else:\n # Remove self.outer_indices from lattice, and use resulting BL to get NL_nm and KL_nm\n # print 'magnetic_gyro_lattice_class: BL = ', self.lattice.BL\n # print 'magnetic_gyro_lattice_class: keep = ', self.inner_indices\n xytmp, self.NL_nm, self.KL_nm, self.BL_nm, self.PVxydict = \\\n le.remove_pts(self.inner_indices, self.lattice.xy, self.lattice.BL, PVxydict=self.lattice.PVxydict,\n PV=self.lattice.PV)\n\n # print 'lp[meshfn_exten] = ', self.lp['meshfn_exten']\n # Get inner boundary\n self.inner_boundary = mgfns.calc_boundary_inner(self, check=False)\n # Use dh to get indices of xy_inner that are on the 'inner' network's boundary\n # Note match_values returns inds such that vals[inds] ~= arr\n if self.inner_boundary is not None:\n self.inner_boundary_inner = dh.match_values(self.inner_boundary, self.inner_indices)\n else:\n self.inner_boundary_inner = None\n # print 'self.inner_indices = ', self.inner_indices\n # print 'self.inner_boundary = ', self.inner_boundary\n # print 'self.inner_boundary_inner = ', self.inner_boundary_inner\n # sys.exit()\n\n # Other attributes that can be calculated\n self.matrix = matrix\n self.eigval = eigval\n self.eigvect = eigvect\n self.localization = None\n self.edge_localization = None\n self.ipr = None","def iter_neighbors(x: int, y: int) -> t.Generator[COORDINATE, None, None]:\n yield x - 1, y\n yield x + 1, y\n yield x, y - 1\n yield x, y + 1","def getPosicion(self):\r\n\t\treturn [self._x, self._y]","def xstagg_xy_coordinates(self):\n\n x_s = self.corner_grid.x0 + np.arange(self.nx+1) * self.dx\n y = self.center_grid.y0 + np.arange(self.ny) * self.dy\n return np.meshgrid(x_s, y)","def getLattice(self):\n raise NotImplementedError(\"The must be overloaded\")","def coordinates(self):\n return self.xy","def make_lattice_points(a=1.0, lattice_type=\"sc\",\r\n ind_min=-10, ind_max=10, CAR=None):\r\n\r\n # generate basis\r\n if lattice_type == \"sc\":\r\n a1 = np.array([1., 0., 0.])\r\n a2 = np.array([0., 1., 0.])\r\n a3 = np.array([0., 0., 1.])\r\n elif lattice_type == \"fcc\":\r\n a1 = np.array([0.5, 0.5, 0.])\r\n a2 = np.array([0., 0.5, 0.5])\r\n a3 = np.array([0.5, 0., 0.5])\r\n elif lattice_type == \"bcc\":\r\n a1 = np.array([0.5, 0.5, -0.5])\r\n a2 = np.array([-0.5, 0.5, 0.5])\r\n a3 = np.array([0.5, -0.5, 0.5])\r\n elif lattice_type == \"hcp\":\r\n if CAR is None:\r\n # default c-to-a ratio = 2.0 * np.sqrt(2.0 / 3.0)\r\n CAR = 2.0 * np.sqrt(2.0 / 3.0)\r\n a1 = np.array([1.0, 0., 0.])\r\n a2 = np.array([-0.5, 0.5*np.sqrt(3.0), 0.])\r\n a3 = np.array([0.0, 0.0, CAR])\r\n else:\r\n raise ValueError(\"Invalid lattice_type: \", lattice_type)\r\n\r\n # generate indices\r\n ind_list = np.arange(ind_min, ind_max + 1, 1)\r\n h, k, l = np.meshgrid(ind_list, ind_list, ind_list)\r\n\r\n h = np.reshape(h, (h.size, 1))\r\n k = np.reshape(k, (k.size, 1))\r\n l = np.reshape(l, (l.size, 1))\r\n\r\n hkl = np.hstack((np.hstack((h, k)), l))\r\n\r\n # calculate coordinates\r\n if lattice_type != \"hcp\":\r\n A = np.vstack((np.vstack((a1, a2)), a3)) # lattice\r\n return a * np.dot(hkl, A)\r\n else:\r\n A = np.vstack((np.vstack((a1, a2)), a3)) # lattice\r\n A_coor = a * np.dot(hkl, A)\r\n B_coor = np.zeros((2*len(A_coor), 3))\r\n B_coor[::2] = A_coor\r\n B = 2./3.*a1 + 1./3.*a2 + 0.5*a3 # the other atom in the basis\r\n B_coor[1::2] = A_coor + a * np.tile(B[None, :], (len(A_coor), 1))\r\n return B_coor.copy()","def ij_coordinates(self):\n\n x = np.arange(self.nx)\n y = np.arange(self.ny)\n return np.meshgrid(x, y)","def index_coords(data, origin=None):\r\n ny, nx = data.shape[:2]\r\n if origin is None :\r\n origin_x, origin_y = nx // 2, ny // 2\r\n else :\r\n origin_x, origin_y = origin\r\n x, y = np.meshgrid(np.arange(nx), np.arange(ny))\r\n x -= origin_x\r\n y -= origin_y\r\n return x, y","def _coord(xend, yend):\n x = np.random.randint(0, xend)\n y = np.random.randint(0, yend)\n return x, y","def get_coords(self):\n return [self.x,self.y,self.w,self.h]","def extractCoords(self):\n if not self.rank:\n logging.info('Extracting atomic poitions')\n\n # Extract coordinates from liggghts\n self.lmp.command('variable x atom x')\n x = Rxn.lmp.extract_variable(\"x\", \"group1\", 1)\n\n self.lmp.command('variable y atom y')\n y = Rxn.lmp.extract_variable(\"y\", \"group1\", 1)\n\n self.lmp.command('variable z atom z')\n z = Rxn.lmp.extract_variable(\"z\", \"group1\", 1)\n\n coords = np.zeros((self.lmp.get_natoms(),3))\n\n for i in range(self.lmp.get_natoms()):\n coords[i,:] = x[i], y[i], z[i]\n\n self.lmp.command('variable x delete')\n self.lmp.command('variable y delete')\n self.lmp.command('variable z delete')\n\n return coords","def box2pts(x1: int, y1: int, x2: int, y2: int) -> np.ndarray:\n return np.array([[x1, y1], [x2, y1], [x2, y2], [x1, y2]])","def linecut_points( **kwargs ):\n npoints = kwargs.get('npoints', 320)\n extents = kwargs.get('extents',None)\n lims = kwargs.get('lims', (-80.,80.))\n direc = kwargs.get('direc', (np.pi/2, 0.))\n origin = kwargs.get('origin', vec3(0.,0.,0.))\n\n if extents is not None:\n lims = (-extents, extents)\n\n # Prepare set of points for plot \n t = np.linspace( lims[0], lims[1], npoints )\n unit = vec3()\n th = direc[0]\n ph = direc[1] \n unit.set_spherical(1, th, ph) \n # Convert vec3s to ndarray\n unit = np.array(unit)\n origin = np.array(origin) \n #\n XYZ = origin + np.outer(t, unit)\n X = XYZ[:,0]\n Y = XYZ[:,1]\n Z = XYZ[:,2]\n \n return t, X, Y, Z, lims","def index_coords(data, origin=None):\n ny, nx = data.shape[:2]\n if origin is None:\n origin_x, origin_y = nx // 2, ny // 2\n else:\n origin_x, origin_y = origin\n x, y = np.meshgrid(np.arange(nx), np.arange(ny))\n x -= origin_x\n y -= origin_y\n return x, y","def get_points(self, npoints: int):\n\n R = sorted(np.random.rand(npoints) * 2. * np.pi)\n\n xx = self.cx + self.a * np.cos(R) * np.cos(self.angle_rad) - self.b * np.sin(R) * np.sin(\n self.angle_rad)\n\n yy = self.cy + self.a * np.cos(R) * np.sin(self.angle_rad) + self.b * np.sin(R) * np.cos(\n self.angle_rad)\n\n return R, xx, yy","def get_random_points(N): \n x1 = np.random.uniform(-1,1,N)\n x2 = np.random.uniform(-1,1,N)\n return (x1,x2)","def coordinates(self):","def get_coordinate_lists(self, crs=None):\n x, y = self.vertices.vectors()[:2]\n if crs is not None and (crs != self.crs):\n x, y = _reproject((x,y), self.crs, crs)\n return x, y","def get_coordinates(self):\n return np.array([(n.x, n.y) for n in self.nodes])","def get_node_points(node):\n for item in coordinate_list:\n if item[0] == node.value:\n return (item[1], item[2])","def getNodeList(x, y, type):\n\t\n\tif type == 0:\n\t\treturn pointListForGrass(x, y)\n\telif type == 1:\n\t\treturn pointListForHorizontal(x, y)\n\telif type == 2:\n\t\treturn pointListForVirticle(x, y)\n\telif type == 3:\n\t\treturn pointListForT(x, y, type)\n\telif type == 4:\n\t\treturn pointListForT(x, y, type)\n\telif type == 5:\n\t\treturn pointListForT(x, y, type)\n\telif type == 6:\n\t\treturn pointListForT(x, y, type)\n\telif type == 7:\n\t\treturn pointListForPlus(x, y)\n\telif type == 8:\n\t\treturn pointListForCurve(x, y, type)\n\telif type == 9:\n\t\treturn pointListForCurve(x, y, type)\n\telif type == 10:\n\t\treturn pointListForCurve(x, y, type)\n\telif type == 11:\n\t\treturn pointListForCurve(x, y, type)\n\telse:\n\t\treturn []","def _getLatLonGrid(self, lats, lons):\n numLats, numLons = lats.shape\n\n #coordGrid = [[0 for lon in range(numLons)] for lat in range(numLats)]\n coordGrid = np.ndarray((numLats, numLons, 2))\n for lat in range(len(lats)):\n for lon in range(len(lons[lat])):\n # Moved handling of pygrib version hack to _getIndex. Since the\n # data matches up with the grid ordering given in lats and lons,\n # we have to maintain that ordering in our created grid.\n coordGrid[lat, lon, 0] = lats[lat][lon]\n coordGrid[lat, lon, 1] = lons[lat][lon]\n\n\n return coordGrid","def g_xy(self):\n for x in range(self.size.x):\n for y in range(self.size.y):\n yield self.p[0] + Vect(x, y)","def get_2d_bb_points(bbox):\n\n cords = np.zeros((4, 4))\n extent = bbox.extent\n # arrange in clockwise to satisify the requirement in PyVisiLibity\n cords[0, :] = np.array([extent.x, extent.y, 0, 1])\n cords[1, :] = np.array([extent.x, -extent.y, 0, 1])\n cords[2, :] = np.array([-extent.x, -extent.y, 0, 1])\n cords[3, :] = np.array([-extent.x, extent.y, 0, 1])\n\n T_world = BboxUtils.get_matrix(carla.Transform(bbox.location, bbox.rotation))\n world_cords = np.dot(T_world, np.transpose(cords))[:2, :]\n return world_cords","def xy(self):\n ...","def all_cells(self):\n \"\"\"\n Note that we use the convention that the first cell is (1,1)\n \"\"\"\n spart_star = self.circle_star()\n part = Partition(list(spart_star))\n coordinates = part.cells()\n coordinates = [(x+1, y+1) for x, y in coordinates]\n return coordinates","def twoEntryPoints(self):\n points = []\n if self.isRed:\n for x in range(self.midWidth, self.width):\n for y in range(0, self.height):\n if (x, y) not in self.walls:\n adjacent = self.adjacentValidPoints(x, y)\n if len(adjacent) == 2:\n points.append((x, y))\n else:\n for x in range(0, self.midWidth-1):\n for y in range(0, self.height):\n if(x, y) not in self.walls:\n adjacent = self.adjacentValidPoints(x, y)\n if len(adjacent) == 2:\n points.append((x, y))\n return points","def pointListForGrass(x, y):\n\n\treturn []\t# No points are made for grass","def coordinates(self, mask):\n y,x = mask.nonzero()\n return list(zip(x,y))","def get_topleft_coords(self, label):\n return map(lambda coord: tuple(coord), self.coords[label])","def getCartesianPoints2(r, theta, center):\n x = r * np.cos(theta) + center[0]\n y = r * np.sin(theta) + center[1]\n\n return x, y","def get_neighbors(grid, x, y):\n out = []\n if x > 0:\n out.append(grid[x-1, y])\n if y > 0:\n out.append(grid[x, y-1])\n if y < grid.shape[1] - 1:\n out.append(grid[x, y+1])\n if x < grid.shape[0] - 1:\n out.append(grid[x+1, y])\n return out","def cells(self):\n \"\"\"\n Note that we use the convention that the first cell is (1,1)\n \"\"\"\n spart_star = self.star()\n part = Partition(list(spart_star))\n coordinates = part.cells()\n coordinates = [(x+1, y+1) for x, y in coordinates]\n return coordinates","def square(lattice_constant: float, number_of_rows: int, number_of_cols: int, starting_point: mp.Vector3) -> list:\n lattice_sites = [starting_point]\n lattice_vectors = (mp.Vector3(lattice_constant, 0),\n mp.Vector3(0, lattice_constant))\n\n for col in range(number_of_cols):\n for row in range(number_of_rows):\n new_point = lattice_sites[row] + (lattice_vectors[1]) + col * (lattice_vectors[0])\n lattice_sites.append(new_point)\n new_point = lattice_sites[col] + (col * lattice_vectors[0]) - (col * lattice_vectors[1])\n lattice_sites.append(new_point)\n\n return lattice_sites","def lonlat(n_lon: int, n_lat: int) -> List[Tuple[float, float]]:\n grid = []\n for lon in np.linspace(0, 360.0 - 360.0 / n_lon, n_lon):\n for lat in np.linspace(-90, 90, n_lat):\n grid.append((lon, lat))\n return grid","def getXYZ(self, layout=None):\n def mesh2d(xlim, ylim):\n xx = [[xlim[0],xlim[1]],\n [xlim[0],xlim[1]]]\n yy = [[ylim[0],ylim[0]],\n [ylim[1],ylim[1]]]\n return xx,yy\n def calc(x, y, z, normal, offset):\n unknown = normal.dot(offset) - normal.vec[0]*x - normal.vec[1]*y - normal.vec[2]*z\n return unknown\n \n xlim = [-1,1]\n ylim = [-1,1]\n zlim = [-1,1]\n n = self.normal\n off = self.offset\n \n if n.vec[2] == 0:\n if n.vec[1] == 0:\n if n.vec[0] == 0:\n raise ValueError(\"Normal vector is zero vector.\")\n else:\n #cannot generate z or y but can x, try generating x for yz mesh\n yy, zz = mesh2d(ylim, zlim)\n xx = [[None,None],[None,None]]\n for i in [0,1]:\n for j in [0,1]:\n xx[i][j] = calc(0, yy[i][j], zz[i][j], n, off)\n else:\n #cannot generate z but can y, try generating y for xz mesh\n xx, zz = mesh2d(xlim, zlim)\n yy = [[None,None],[None,None]]\n for i in [0,1]:\n for j in [0,1]:\n yy[i][j] = calc(xx[i][j], 0, zz[i][j], n, off)\n else:\n #try generating z\n xx, yy = mesh2d(xlim, ylim)\n zz = [[None,None],[None,None]]\n for i in [0,1]:\n for j in [0,1]:\n zz[i][j] = calc(xx[i][j], yy[i][j], 0, n, off)\n return xx, yy, zz","def coord (i, j):\r\n return j, i"],"string":"[\n \"def getLatticePoints():\\n latticePoints = []\\n\\n for y in arange(yMin, yMax + yStep, yStep):\\n for x in arange(xMin, xMax + xStep, xStep):\\n latticePoints.append(LatticePoint(x, y))\\n\\n \\n return latticePoints\",\n \"def get_lattice_points(self) -> List[np.ndarray]:\\n lattice_points = []\\n for factor in self.get_all_factors():\\n lp = cast_integer_matrix(np.dot(self.left_inv, factor))\\n lattice_points.append(lp)\\n return lattice_points\",\n \"def get_points(self):\\r\\n return self.nx*self.ny*self.nz\",\n \"def make_xy(N, origin=None):\\r\\n if type(N) == int :\\r\\n ny, nx = N, N\\r\\n elif len(N) == 2 :\\r\\n ny, nx = N \\r\\n elif len(N) == 1 and (type(N) == tuple or type(N) == list):\\r\\n ny = N[0] \\r\\n nx = 0\\r\\n if ny != 0 and nx != 0 :\\r\\n x, y = np.meshgrid(np.arange(nx), np.arange(ny))\\r\\n if (origin is None) or (origin == 'centre') :\\r\\n origin_x, origin_y = nx // 2 - 1, ny // 2 - 1\\r\\n x -= origin_x\\r\\n y -= origin_y\\r\\n elif origin[0] == 0 and (origin[1] == 0):\\r\\n x = ((x + nx // 2 - 1) % nx) - (nx // 2 - 1)\\r\\n y = ((y + ny // 2 - 1) % ny) - (ny // 2 - 1)\\r\\n return x, y\\r\\n elif ny != 0 and nx == 0 :\\r\\n y = np.arange(ny)\\r\\n if (origin is None) or (origin == 'centre') :\\r\\n origin_y = ny // 2 - 1\\r\\n y -= origin_y\\r\\n elif origin[0] == 0 :\\r\\n y = ((y + ny // 2 - 1) % ny) - (ny // 2 - 1)\\r\\n return y\",\n \"def lattice_coords(cutoffs):\\n Nx = cutoffs[0]\\n Ny = cutoffs[1]\\n Nz = cutoffs[2]\\n \\n return np.array([np.kron(np.arange(-Nx,Nx+1, dtype = int), np.kron(np.ones(2*Ny+1,dtype = int), np.ones(2*Nz+1, dtype = int)) ),\\n np.kron(np.ones(2*Nx+1, dtype = int), np.kron(np.arange(-Ny,Ny+1, dtype = int), np.ones(2*Nz+1, dtype = int)) ),\\n np.kron(np.ones(2*Nx+1, dtype = int), np.kron(np.ones(2*Ny+1, dtype = int), np.arange(-Nz, Nz+1, dtype = int)) )]).T\",\n \"def lattice(self):\\n return self._lattice\",\n \"def __getxy(x1, y1, x2, y2):\\n\\t\\treturn x1*27+y1*9+x2*3+y2\",\n \"def get_xy(self, x, y):\\r\\n\\t\\treturn self.grid[y, x]\",\n \"def latlon_2_grid(x, y, z, origin):\\n new_y = (y - origin[1]) * 111111\\n new_x = (x - origin[0]) * (111111 * np.cos(origin[1] * (np.pi/180)))\\n return new_x, new_y, z\",\n \"def xy(self):\\n return self.to_xyah()[0:2]\",\n \"def xyxy(x, y, hd1, hd2):\\n wcs1 = wcs.WCS(hd1)\\n wcs2 = wcs.WCS(hd2)\\n ra, dec = wcs1.all_pix2world(x, y, 1)\\n x2, y2 = wcs2.all_world2pix(ra, dec, 1)\\n return x2, y2\",\n \"def get_xy_grid(nx, ny):\\n\\tfor n in [nx, ny]:\\n\\t\\tif not isodd(n):\\n\\t\\t\\traise Exception(\\\"[get_xy_grid] only accept odd number\\\")\\n\\n\\tx, y = np.mgrid[-(nx-1)/2:(nx+1)/2, -(ny-1)/2:(ny+1)/2]\\n\\n\\treturn x, y\",\n \"def obtain_points(self):\\n # Swapaxes makes the output a column rather than a row\\n return np.swapaxes(np.array([np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"GridCoordinates\\\"][\\\"CoordinateX\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"GridCoordinates\\\"][\\\"CoordinateY\\\"][\\\" data\\\"][:, :, :]),\\n np.ndarray.flatten(self.data[\\\"Base\\\"][\\\"Zone1\\\"][\\\"GridCoordinates\\\"][\\\"CoordinateZ\\\"][\\\" data\\\"][:, :, :])]), 0, 1)\",\n \"def coordinate_in_lattice(v,n,m):\\n y=int(v/n);\\n x=(v%n);\\n\\n return (x,y)\",\n \"def _get_xy_lims(self):\\n \\n x = self.datapos[0] - 1\\n y = self.datapos[1] - 1\\n\\n return x, y\",\n \"def get_cells(pts, inv_cell_width, Ny, Nx, log=sys.stdout):\\n lib = _initlib()\\n p = require(pts, dtype=float64, requirements=['C']) \\n npts = p.shape[0]\\n assert(p.shape ==(npts,3))\\n out = empty(npts, dtype=int64)\\n\\n res = lib.find_lattice(p, npts, inv_cell_width, Ny, Nx, out)\\n return out\",\n \"def origin():\\n\\n # indices: [axis, point]\\n return numpy.zeros((3, 1))\",\n \"def coords2D(self):\\n return (self.x, self.y)\",\n \"def xy(self):\\n xcol = self.xx.reshape(-1, 1)\\n ycol = self.yy.reshape(-1, 1)\\n return np.column_stack([xcol, ycol])\",\n \"def xy(self) -> Tuple[float, float]:\\n return (self.x, self.y)\",\n \"def xy_coordinates(self):\\n\\n return np.meshgrid(self.x_coord, self.y_coord)\",\n \"def _xy_locs(mask):\\n y, x = mask.nonzero()\\n return list(zip(x, y))\",\n \"def lattice_pos(npart,r,box):\\n\\n #Calculo cantidad de celdas por lado\\n n = int(np.ceil(np.sqrt(npart)))\\n \\n #calculo el centro de la celda\\n nf = 1.0/float(n)\\n \\n #Calculo las posiciones de todas las celdas disponibles agregando un r% de randomizacion\\n \\n celdas = [[i*nf +0.5*nf + r*np.random.uniform(low=-box/2,high=box/2),j*nf + 0.5*nf+ r*np.random.uniform(low=-box/2,high=box/2),k*nf + 0.5*nf+ r*np.random.uniform(low=-box/2,high=box/2)]\\n for i in range(n) for j in range(n) for k in range(n)]\\n \\n #Mezclo las posiciones de las celdas\\n np.random.shuffle(celdas)\\n \\n X = np.array(celdas[0:npart])\\n return X\",\n \"def _getitem_2d(self, pos):\\n if isinstance(pos, list):\\n if isinstance(pos[0], (int, np.integer)): # single point\\n return self[pos[0], pos[1]]\\n else:\\n return [self[p] for p in pos]\\n elif isinstance(pos, np.ndarray):\\n if isinstance(pos[0], (int, np.integer)): # single point\\n return np.array(self[pos[0], pos[1]])\\n else:\\n return np.array([self[p] for p in pos])\\n # compute coordinates from OneDimGrids of its master.\\n x = self.master.x[pos[0]]\\n y = self.master.y[pos[1]]\\n # TODO: Refactor the following code to avoid the use of double for loops and list comprehensions.\\n if (not isinstance(x, np.ndarray)) and (not isinstance(y, np.ndarray)): # x and y are scalars.\\n return np.array([x, y])\\n if not isinstance(x, np.ndarray): # x is a scalar.\\n return np.array([np.array([x, _y]) for _y in y])\\n elif not isinstance(y, np.ndarray): # y is a scalar.\\n return np.array([np.array([_x, y]) for _x in x])\\n else:\\n xy = []\\n for _x in x: # vectorize this operation.\\n row = []\\n for _y in y:\\n row.append(np.array([_x, _y]))\\n xy.append(np.array(row))\\n return np.array(xy)\",\n \"def _gather_points(self):\\n # This is just a stub for now. We should really find the lines only\\n # inside the screen range here.\\n\\n x = self.index.get_data()\\n y = self.value.get_data()\\n rad= min(self.width/2.0,self.height/2.0)\\n sx = x*rad+ self.x + self.width/2.0\\n sy = y*rad+ self.y + self.height/2.0\\n\\n points = transpose(array((sx,sy)))\\n self._cached_data_pts = points\\n self._cache_valid = True\\n return\",\n \"def get_neighbors(point):\\n pt = point.copy()\\n output= [point.copy() for i in range(4)]\\n output[0:2] = map(Point.setY, output[0:2], [pt.getY()+ i for i in range(-1,2,2)])\\n output[2:4]= map(Point.setX, output[2:4], [pt.getX()+ i for i in range(-1,2,2)])\\n return output\",\n \"def xy(self) -> Tuple[int, int]:\\n return self._x, self._y\",\n \"def points(self, ntheta, nlayer):\\n exec self.x\\n exec self.y\\n return [x, y]\",\n \"def afficher_points_2D(set_points):\\n X, Y = [p[0][0] for p in set_points], [p[0][1] for p in set_points]\\n return(X, Y)\",\n \"def lattice(image, res=20):\\n\\tH, W = image.shape[0], image.shape[1]\\n\\txs = np.linspace(0, W, res).astype(np.uint16)\\n\\tys = np.linspace(0, H, res).astype(np.uint16)\\n\\tpts = []\\n\\tfor x in xs:\\n\\t\\tfor y in ys:\\n\\t\\t\\tpts.append((x,y))\\n\\treturn pts\",\n \"def get_random_coordinates(self):\\n array_shape = np.shape(self.cells) # type: tuple\\n points_on_island = []\\n for i in range(1, array_shape[0] - 1):\\n for j in range(1, array_shape[1] - 1):\\n points_on_island.append((i, j))\\n random.shuffle(points_on_island)\\n return points_on_island\",\n \"def p2p_xyz(start_point, end_point, top_left_cor, cellsize, dem):\\n start_cell = (int((start_point[0] - top_left_cor[0]) / cellsize[0]),\\n int((start_point[1] - top_left_cor[1]) / cellsize[1]))\\n end_cell = (int((end_point[0] - top_left_cor[0]) / cellsize[0]),\\n int((end_point[1] - top_left_cor[1]) / cellsize[1]))\\n cells = misc.get_line(start_cell, end_cell) \\n pnts = []\\n elev = []\\n \\n dem_elv = dem[:,1]\\n dem_indx = dem[:,2:4]\\n\\n for cell in cells:\\n x = top_left_cor[0] + cell[0] * cellsize[0] + cellsize[0] / 2\\n y = top_left_cor[1] + cell[1] * cellsize[1] + cellsize[1] / 2\\n #xy_indx=[str(cell[0]),str(cell[1])]\\n z_indx=np.logical_and(np.equal(dem_indx[:,0],cell[0]),np.equal(dem_indx[:,1],cell[1]))\\n try:\\n z=dem_elv[z_indx][0]\\n except (np.sum(z_indx)>1):\\n print(\\\"Oops! That was more than one indices in dem matching the query index (in getCellValue)\\\")\\n #z_indx = [i for i,j in enumerate(dem_indx) if j == xy_indx]\\n z = float(dem_elv[z_indx])\\n pnts.append((x, y))\\n elev.append(z)\\n return pnts, elev\",\n \"def _generate_coords(self):\\n coords = np.dstack([self.X.ravel(), self.Y.ravel()])[0]\\n return coords, spatial.cKDTree(coords)\",\n \"def getxySorted(self):\\n from operator import itemgetter\\n x,y=self.getxy()\\n s=sorted(zip(x,y), key=itemgetter(0))\\n x,y = zip(*s)\\n return x,y\",\n \"def getXY(self):\\n return (self.X,self.Y)\",\n \"def xy(self):\\n return self.coords.xy\",\n \"def positions(r):\\n\\n X = []\\n Y = []\\n\\n leftx = -r*(nx - 1) / 2\\n topy = -r*(ny - 1) / 2\\n\\n for i in range(0, nx):\\n for j in range(0, ny):\\n X.append(leftx + r * i)\\n Y.append(topy + r * j)\\n\\n return (X, Y)\",\n \"def generate_L_shaped_domain(nx, ny, Lx1,Lx2,Ly1,Ly2):\\n X1,Y1=generate_square_domain(x_min=0, x_max=Lx2, y_min=0, y_max=Ly1,\\\\\\n nx=nx, ny=np.floor(ny/2))\\n X2,Y2=generate_square_domain(x_min=0, x_max=Lx1, y_min=Ly1, y_max=Ly2,\\\\\\n nx=np.floor(nx/2), ny=ny)\\n return [[X1, Y1], [X2,Y2]]\",\n \"def ipset_x_2d():\\n x1 = np.linspace(0, 10, 11)\\n x2 = np.linspace(-3, 3, 11)\\n return IPSet(x=np.stack((x1, x2), axis=1), y=np.linspace(-1, 1, 11), x_new=np.stack((x1[1:-1], x2[1:-1]), axis=1))\",\n \"def point(self):\\n bfsize = card(self.basefield)\\n one = self.basefield.one\\n t = self.basefield.zero\\n if len(self) == 2 or (self.a1 == self.a2 == self.a3 == self.basefield.zero):\\n while self.basefield.Legendre(t) != 1:\\n s = self.basefield.createElement(bigrandom.randrange(bfsize))\\n t = self.cubic(s)\\n if not t:\\n return [s, t]\\n t = self.basefield.sqrt(t)\\n r = bigrandom.randrange(2)\\n if r:\\n return [s, -t]\\n return [s, t]\\n elif self.ch != 2 and self.ch != 3:\\n sform = self.simple()\\n while sform.basefield.Legendre(t) != 1:\\n s = sform.basefield.createElement(bigrandom.randrange(bfsize))\\n t = (s**3+sform.a*s+sform.b)\\n x = (s-3*self.b2) // (36*one)\\n y = (sform.basefield.sqrt(t) // (108*one)-self.a1*x-self.a3)//(2*one)\\n return [x, y]\\n elif self.ch == 3:\\n while sform.basefield.Legendre(t) != 1:\\n s = self.basefield.createElement(bigrandom.randrange(bfsize))\\n t = (s**3+self.a2*s**2+self.a4*s+self.a6)\\n return [s, self.basefield.sqrt(t)]\\n else:\\n raise NotImplementedError(\\\"This is not implemented.\\\")\",\n \"def _build_point_grid(n_per_side: int) -> np.ndarray:\\n offset = 1 / (2 * n_per_side)\\n points_one_side = np.linspace(offset, 1 - offset, n_per_side)\\n points_x = np.tile(points_one_side[None, :], (n_per_side, 1))\\n points_y = np.tile(points_one_side[:, None], (1, n_per_side))\\n points = np.stack([points_x, points_y], axis=-1).reshape(-1, 2)\\n return points\",\n \"def render_points_2d(self, **kwds):\\n return point2d(self.coordinates_of(self.points), **kwds)\",\n \"def getCoords(self): # real signature unknown; restored from __doc__\\r\\n pass\",\n \"def get_traj_point(box):\\n x1, _, x2, y2 = box\\n return [(x1 + x2) / 2.0, y2]\",\n \"def get_xy(ncenters, ndim, rstate):\\n flag = True\\n while flag:\\n buff = 10 * ncenters\\n args = [buff,ndim]\\n randxy = rstate.rand(*args)*2 - 1. # Multi-dimensional array of -1 to 1 values\\n # Generate Radius**2\\n radius2 = np.sum(randxy**2,1)\\n # Grab the good ones\\n gdr2 = np.where(radius2 < 1.)[0]\\n # Check we have enough\\n if len(gdr2) > ncenters:\\n flag = False\\n # Return the first ncenters\\n return randxy[gdr2[0:ncenters],:]\",\n \"def ystagg_xy_coordinates(self):\\n\\n x = self.center_grid.x0 + np.arange(self.nx) * self.dx\\n y_s = self.corner_grid.y0 + np.arange(self.ny+1) * self.dy\\n return np.meshgrid(x, y_s)\",\n \"def xyz(self, i):\\n return self.xp[i], self.yp[i], self.zp[i]\",\n \"def points(self):\\n return np.vstack((self.x(), self.y()))\",\n \"def get_base_coords(self):\\n num_bases = len(self.tour)\\n base_coords = np.zeros((num_bases,3), dtype=float)\\n for i,base in enumerate(self.tour):\\n helix_num = base.h\\n helix_pos = base.p\\n helix = self.helix_list[helix_num]\\n base_coords[i] = base.coordinates\\n return base_coords\",\n \"def grid_coords(self):\\n return [(x, y) for y in range(self.height) for x in range(self.width)]\",\n \"def sub2xy(self, ix, iy):\\n x = self.Lx * (ix + .5)/self.Nx\\n y = self.Ly * (iy + .5)/self.Ny\\n return x, y\",\n \"def get_minnpix(self, pixel_size, radius):\\n\\n npix = latticepoints(radius,pixel_size)\\n return npix\",\n \"def GetParametricCoords(self):\\n ...\",\n \"def get_gridinfo(filename, xpoints, ypoints):\\n with open(f\\\"{filename[:-4]}.wld\\\", encoding=\\\"ascii\\\") as fh:\\n lines = fh.readlines()\\n dx = float(lines[0])\\n dy = float(lines[3])\\n west = float(lines[4])\\n north = float(lines[5])\\n south = north + dy * ypoints\\n lats = np.arange(0, ypoints) * (0 - dy) + south\\n lons = np.arange(0, xpoints) * dx + west\\n return lons, lats\",\n \"def _get_grid_coord(self, point):\\n return tuple([int(point[i] / self._cell_length) for i in range(self._dim)])\",\n \"def _get_pt_tuple(pnt1, pnt2):\\n return tuple(map(_map_x_dim(tuple(pnt1)), pnt2))\",\n \"def ricomLocal2LL(points,lat0=0,long0=0,latoff=0,longoff=0): \\n import math\\n bigr = 6378136.0\\n dlong = longoff-long0\\n dlat = latoff-lat0\\n clat0 = math.cos(lat0*math.pi/180.0)\\n numPts = len(points)\\n n = 0\\n pointsLL=[]\\n while n<numPts:\\n x = points[n][0]/(bigr*(math.pi/180.0)*clat0) - dlong\\n y = points[n][1]/(bigr*(math.pi/180.0)) - dlat\\n pointsLL.append([x,y])\\n n+=1\\n \\n return pointsLL\",\n \"def candidate_start_points_lattice(bounds, nums=3):\\n\\n if isinstance(nums, int):\\n nums = repeat(nums)\\n\\n linspaces = [np.linspace(start, end, num) for (start, end), num\\n in zip(bounds, nums)]\\n return np.vstack(a.flatten() for a in np.meshgrid(*linspaces))\",\n \"def getCoord(self, i):\\n _x = self.__xpts[i]\\n _y = self.__ypts[i]\\n return _x, _y\",\n \"def get_point_on(self, s):\\n\\n x = self.n1.x * (1 - s) + self.n2.x * s\\n y = self.n1.y * (1 - s) + self.n2.y * s\\n z = self.n1.z * (1 - s) + self.n2.z * s\\n\\n return [x, y, z]\",\n \"def points(self):\\n p = []\\n for v in self.iter():\\n p.append((v.x, v.y))\\n return p\",\n \"def point_location(tri, p): \\n simplex_index = tri.find_simplex(p)\\n bc = []\\n for id_, point in zip(simplex_index, p):\\n # Calculate the two first barycentric coordinates for the relevant\\n # simplex\\n b = tri.transform[id_, :2].dot(point-tri.transform[id_, 2])\\n bc.append(np.c_[np.atleast_2d(b), 1-b.sum()])\\n # Create the full array and squeeze the shit out of it\\n bc = np.array(bc).squeeze()\\n return simplex_index, bc\",\n \"def _get_xy_coords(self, exterior, coord_type):\\n if coord_type == 'x':\\n return exterior.coords.xy[0]\\n elif coord_type == 'y':\\n return exterior.coords.xy[1]\",\n \"def __init__(self, lattice, lp, xytup=None, NL=None, KL=None, PVx=None, PVy=None,\\n BL_nm=None, NL_nm=None, KL_nm=None,\\n Omg=None, OmK=None, matrix=None, eigval=None, eigvect=None, eps=1e-8, overwrite=False):\\n # xytup is a tuple of inner points, outer points. Define self.xy to be all sites, including immobile ones\\n self.lattice = lattice\\n # lp contains Omg, Omk, als. With weights, Omg = 1.5, otherwise Omg = 1.0\\n # Omk = k_m l^2 / I omega -> 0.86 in original experiments\\n # aoverl = 0.0305/.038\\n self.lp = lp\\n self.inner_indices = None\\n self.outer_indices = None\\n\\n if xytup is None:\\n # Create self.xy and self.xy_inner\\n self.xy = lattice.xy\\n if 'roi' in self.lp:\\n self.xy_inner = le.pts_in_polygon(self.xy, self.lp['roi'])\\n else:\\n # get boundary of the lattice and denote these particles as the outer particles\\n # boundary = le.extract_boundary(self.xy, self.lattice.NL, self.lattice.KL, self.lattice.BL,\\n # check=False)\\n boundary = self.lattice.get_boundary()\\n if boundary is None:\\n self.xy_inner = self.xy\\n elif isinstance(boundary, tuple):\\n # There are multiple boundaries. Exclude all of them from inner_indices\\n inners = np.arange(len(self.xy))\\n outers = []\\n for bndy in boundary:\\n inners = np.setdiff1d(inners, np.array(bndy))\\n outers.append(bndy)\\n\\n self.inner_indices = np.hstack(inners)\\n self.outer_indices = np.hstack(outers)\\n self.xy_inner = self.xy[self.inner_indices]\\n else:\\n self.inner_indices = np.setdiff1d(np.arange(len(self.xy)), np.array(boundary))\\n self.outer_indices = np.array(boundary)\\n self.xy_inner = self.xy[self.inner_indices]\\n else:\\n self.xy = xytup[1]\\n self.xy_inner = xytup[0]\\n\\n if NL is not None and KL is not None:\\n self.NL = NL\\n self.KL = KL\\n # determine if shortrange or longrange or intermediate interaction_range from supplied NL\\n # if lp['intrange'] == 1:\\n # nl_meshfn_exten = '_shortrange'\\n if lp['intrange'] > 0:\\n nl_meshfn_exten = '_intrange{0:04d}'.format(mglat.lp['interaction_range'])\\n else:\\n nl_meshfn_exten = ''\\n # Get PVxy if not supplied\\n if PVx is not None and PVy is not None:\\n self.PVx, self.PVy = PVx, PVy\\n else:\\n if (KL > -eps).all():\\n self.PVx = np.zeros_like(NL, dtype=float)\\n self.PVy = np.zeros_like(NL, dtype=float)\\n else:\\n raise RuntimeError('periodic KL is supplied, but PVx and PVy are not supplied')\\n else:\\n self.NL, self.KL, self.PVx, self.PVy, nl_meshfn_exten = mgfns.create_NL_KL_pv(self)\\n\\n # print 'self.xy_inner = ', np.shape(self.xy_inner)\\n # print 'self.xy = ', np.shape(self.xy)\\n if self.inner_indices is None or self.outer_indices is None:\\n self.outer_indices, self.inner_indices, self.total2inner = self.outer_inner(self.xy, self.xy_inner)\\n\\n # Add lattice properties to gyro_lattice_properties, by convention, but don't overwrite params\\n for key in self.lattice.lp:\\n if key not in self.lp:\\n self.lp[key] = self.lattice.lp[key]\\n\\n ########################################################################\\n self.lp['meshfn_exten'] = '_magnetic' + nl_meshfn_exten + '_aol' + sf.float2pstr(self.lp['aoverl'])\\n # For magnetic class, OmK is bond dependent: OmK = 3 mu_0 M^2/ (pi a^5) for each bond\\n if self.lp['Omk'] != -1.0:\\n self.lp['meshfn_exten'] += '_Omk' + sf.float2pstr(self.lp['Omk'])\\n\\n # Build OmK array for couplings\\n self.OmK, lp_Omk, omk_meshfn_exten = mgfns.build_OmK(self, self.lp, None)\\n\\n # Form Omg\\n if Omg == 'auto' or Omg is None:\\n if 'Omg' in self.lp:\\n self.Omg = self.lp['Omg'] * np.ones_like(self.xy_inner[:, 0])\\n else:\\n print 'giving Omg the default value of -1s...'\\n self.Omg = -1.0 * np.ones_like(self.xy_inner[:, 0])\\n if self.lp['Omg'] != -1.0:\\n self.lp['meshfn_exten'] += '_Omg' + sf.float2pstr(self.lp['Omg'])\\n else:\\n self.Omg = Omg\\n if 'Omg' in self.lp:\\n if (self.Omg != self.lp['Omg'] * np.ones(np.shape(self.xy_inner)[0])).any():\\n self.lp['meshfn_exten'] += '_Omgspec'\\n self.lp['Omg'] = -5000\\n else:\\n # Check if the values of all elements are identical\\n kinds = np.nonzero(self.Omg)\\n if len(kinds[0]) > 0:\\n # There are some nonzero elements in Omg. Check if all the same\\n value = self.Omg[kinds[0]]\\n if (Omg[kinds] == value).all():\\n self.lp['Omg'] = value\\n else:\\n self.lp['Omg'] = -5000\\n else:\\n self.lp['Omg'] = 0.0\\n if 'ABDelta' in self.lp:\\n if np.abs(self.lp['ABDelta']) > eps:\\n self.lp['meshfn_exten'] += '_ABd{0:0.3f}'.format(self.lp['ABDelta']).replace('.', 'p').replace('-', 'n')\\n else:\\n self.lp['ABDelta'] = 0.\\n\\n # First check for gaussian disorder\\n if 'V0_pin_gauss' in self.lp and 'V0_spring_gauss' in self.lp:\\n if abs(self.lp['V0_pin_gauss']) > eps or (self.lp['V0_spring_gauss']) > eps:\\n self.lp['dcdisorder'] = True\\n self.lp['meshfn_exten'] += '_pinV' + sf.float2pstr(self.lp['V0_pin_gauss'])\\n self.lp['meshfn_exten'] += '_sprV' + sf.float2pstr(self.lp['V0_spring_gauss'])\\n if 'pinconf' not in self.lp:\\n self.lp['pinconf'] = 0\\n elif self.lp['pinconf'] > 0:\\n self.lp['meshfn_exten'] += '_conf{0:04d}'.format(self.lp['pinconf'])\\n else:\\n self.lp['dcdisorder'] = False\\n\\n # If no gaussian disorder check for flat disorder\\n if 'V0_pin_flat' in self.lp and 'V0_spring_flat' in self.lp and not self.lp['dcdisorder']:\\n if abs(self.lp['V0_pin_flat']) > eps or (self.lp['V0_spring_flat']) > eps:\\n self.lp['dcdisorder'] = True\\n self.lp['meshfn_exten'] += '_pinVflat' + sf.float2pstr(self.lp['V0_pin_flat'])\\n self.lp['meshfn_exten'] += '_sprVflat' + sf.float2pstr(self.lp['V0_spring_flat'])\\n if 'pinconf' not in self.lp:\\n self.lp['pinconf'] = 0\\n elif self.lp['pinconf'] > 0:\\n self.lp['meshfn_exten'] += '_conf{0:04d}'.format(self.lp['pinconf'])\\n else:\\n self.lp['dcdisorder'] = False\\n\\n # If neither gaussian nor flat, input no disorder\\n if not self.lp['dcdisorder']:\\n self.lp['V0_pin_gauss'] = 0.\\n self.lp['V0_spring_gauss'] = 0.\\n self.lp['V0_pin_flat'] = 0.\\n self.lp['V0_spring_flat'] = 0.\\n self.lp['pinconf'] = 0\\n self.lp['dcdisorder'] = False\\n\\n vpin_has_gaussian = self.lp['V0_pin_gauss'] > eps or self.lp['V0_spring_gauss'] > eps\\n vpin_has_flat = self.lp['V0_pin_flat'] > eps or self.lp['V0_spring_flat'] > eps\\n if abs(self.lp['ABDelta']) > eps or vpin_has_gaussian or vpin_has_flat:\\n # In order to load the random (V0) or alternating (AB) pinning sites, look for a txt file with the pinnings\\n # that also has specifications in its meshfn exten, but IGNORE other parts of meshfnexten, if they exist.\\n # Form abbreviated meshfn exten\\n pinmfe = self.get_pinmeshfn_exten()\\n\\n print 'Trying to load offset/disorder to pinning frequencies: '\\n print dio.prepdir(self.lp['meshfn']) + pinmfe\\n # Attempt to load from file\\n if not overwrite:\\n try:\\n self.load_pinning(meshfn=self.lp['meshfn'])\\n # self.Omg = np.loadtxt(dio.prepdir(self.lp['meshfn']) + pinmfe + '.txt')\\n # raise RuntimeError('This means an erronous Omg was saved --where was it saved?')\\n print 'Loaded ABDelta and/or dcdisordered pinning frequencies.'\\n define_Omg_now = False\\n except IOError:\\n define_Omg_now = True\\n else:\\n define_Omg_now = True\\n\\n if define_Omg_now:\\n print 'Could not load ABDelta and/or dcdisordered pinning frequencies, defining them here...'\\n # Make Omg from scratch\\n if abs(self.lp['ABDelta']) > eps:\\n asites, bsites = glatfns.ascribe_absites(self.lattice)\\n self.Omg[asites[self.inner_indices]] += self.lp['ABDelta']\\n self.Omg[bsites[self.inner_indices]] -= self.lp['ABDelta']\\n if vpin_has_flat or vpin_has_gaussian:\\n self.add_dcdisorder()\\n\\n # Save non-standard Omg\\n if 'save_pinning_to_hdf5' in self.lp:\\n if self.lp['save_pinning_to_hdf5']:\\n force_hdf5pin = True\\n else:\\n force_hdf5pin = False\\n else:\\n force_hdf5pin = False\\n self.save_Omg(infodir=self.lp['meshfn'], histogram=False, force_hdf5=force_hdf5pin, overwrite=overwrite)\\n # self.plot_Omg()\\n # np.savetxt(dio.prepdir(self.lp['meshfn']) + pinmfe + '.txt', self.Omg)\\n # self.plot_Omg()\\n\\n ########################################################################\\n\\n # Non magnetic --> nm: taken from lat.NL, lat.KL, these are the inner particles (xy_in) connectivity M x M\\n if BL_nm is not None:\\n self.BL_nm = BL_nm\\n if NL_nm is not None and KL_nm is not None:\\n self.NL_nm = NL_nm\\n self.KL_nm = KL_nm\\n else:\\n self.NL_nm, self.KL_nm = le.BL2NLandKL(self.BL_nm)\\n else:\\n # Remove self.outer_indices from lattice, and use resulting BL to get NL_nm and KL_nm\\n # print 'magnetic_gyro_lattice_class: BL = ', self.lattice.BL\\n # print 'magnetic_gyro_lattice_class: keep = ', self.inner_indices\\n xytmp, self.NL_nm, self.KL_nm, self.BL_nm, self.PVxydict = \\\\\\n le.remove_pts(self.inner_indices, self.lattice.xy, self.lattice.BL, PVxydict=self.lattice.PVxydict,\\n PV=self.lattice.PV)\\n\\n # print 'lp[meshfn_exten] = ', self.lp['meshfn_exten']\\n # Get inner boundary\\n self.inner_boundary = mgfns.calc_boundary_inner(self, check=False)\\n # Use dh to get indices of xy_inner that are on the 'inner' network's boundary\\n # Note match_values returns inds such that vals[inds] ~= arr\\n if self.inner_boundary is not None:\\n self.inner_boundary_inner = dh.match_values(self.inner_boundary, self.inner_indices)\\n else:\\n self.inner_boundary_inner = None\\n # print 'self.inner_indices = ', self.inner_indices\\n # print 'self.inner_boundary = ', self.inner_boundary\\n # print 'self.inner_boundary_inner = ', self.inner_boundary_inner\\n # sys.exit()\\n\\n # Other attributes that can be calculated\\n self.matrix = matrix\\n self.eigval = eigval\\n self.eigvect = eigvect\\n self.localization = None\\n self.edge_localization = None\\n self.ipr = None\",\n \"def iter_neighbors(x: int, y: int) -> t.Generator[COORDINATE, None, None]:\\n yield x - 1, y\\n yield x + 1, y\\n yield x, y - 1\\n yield x, y + 1\",\n \"def getPosicion(self):\\r\\n\\t\\treturn [self._x, self._y]\",\n \"def xstagg_xy_coordinates(self):\\n\\n x_s = self.corner_grid.x0 + np.arange(self.nx+1) * self.dx\\n y = self.center_grid.y0 + np.arange(self.ny) * self.dy\\n return np.meshgrid(x_s, y)\",\n \"def getLattice(self):\\n raise NotImplementedError(\\\"The must be overloaded\\\")\",\n \"def coordinates(self):\\n return self.xy\",\n \"def make_lattice_points(a=1.0, lattice_type=\\\"sc\\\",\\r\\n ind_min=-10, ind_max=10, CAR=None):\\r\\n\\r\\n # generate basis\\r\\n if lattice_type == \\\"sc\\\":\\r\\n a1 = np.array([1., 0., 0.])\\r\\n a2 = np.array([0., 1., 0.])\\r\\n a3 = np.array([0., 0., 1.])\\r\\n elif lattice_type == \\\"fcc\\\":\\r\\n a1 = np.array([0.5, 0.5, 0.])\\r\\n a2 = np.array([0., 0.5, 0.5])\\r\\n a3 = np.array([0.5, 0., 0.5])\\r\\n elif lattice_type == \\\"bcc\\\":\\r\\n a1 = np.array([0.5, 0.5, -0.5])\\r\\n a2 = np.array([-0.5, 0.5, 0.5])\\r\\n a3 = np.array([0.5, -0.5, 0.5])\\r\\n elif lattice_type == \\\"hcp\\\":\\r\\n if CAR is None:\\r\\n # default c-to-a ratio = 2.0 * np.sqrt(2.0 / 3.0)\\r\\n CAR = 2.0 * np.sqrt(2.0 / 3.0)\\r\\n a1 = np.array([1.0, 0., 0.])\\r\\n a2 = np.array([-0.5, 0.5*np.sqrt(3.0), 0.])\\r\\n a3 = np.array([0.0, 0.0, CAR])\\r\\n else:\\r\\n raise ValueError(\\\"Invalid lattice_type: \\\", lattice_type)\\r\\n\\r\\n # generate indices\\r\\n ind_list = np.arange(ind_min, ind_max + 1, 1)\\r\\n h, k, l = np.meshgrid(ind_list, ind_list, ind_list)\\r\\n\\r\\n h = np.reshape(h, (h.size, 1))\\r\\n k = np.reshape(k, (k.size, 1))\\r\\n l = np.reshape(l, (l.size, 1))\\r\\n\\r\\n hkl = np.hstack((np.hstack((h, k)), l))\\r\\n\\r\\n # calculate coordinates\\r\\n if lattice_type != \\\"hcp\\\":\\r\\n A = np.vstack((np.vstack((a1, a2)), a3)) # lattice\\r\\n return a * np.dot(hkl, A)\\r\\n else:\\r\\n A = np.vstack((np.vstack((a1, a2)), a3)) # lattice\\r\\n A_coor = a * np.dot(hkl, A)\\r\\n B_coor = np.zeros((2*len(A_coor), 3))\\r\\n B_coor[::2] = A_coor\\r\\n B = 2./3.*a1 + 1./3.*a2 + 0.5*a3 # the other atom in the basis\\r\\n B_coor[1::2] = A_coor + a * np.tile(B[None, :], (len(A_coor), 1))\\r\\n return B_coor.copy()\",\n \"def ij_coordinates(self):\\n\\n x = np.arange(self.nx)\\n y = np.arange(self.ny)\\n return np.meshgrid(x, y)\",\n \"def index_coords(data, origin=None):\\r\\n ny, nx = data.shape[:2]\\r\\n if origin is None :\\r\\n origin_x, origin_y = nx // 2, ny // 2\\r\\n else :\\r\\n origin_x, origin_y = origin\\r\\n x, y = np.meshgrid(np.arange(nx), np.arange(ny))\\r\\n x -= origin_x\\r\\n y -= origin_y\\r\\n return x, y\",\n \"def _coord(xend, yend):\\n x = np.random.randint(0, xend)\\n y = np.random.randint(0, yend)\\n return x, y\",\n \"def get_coords(self):\\n return [self.x,self.y,self.w,self.h]\",\n \"def extractCoords(self):\\n if not self.rank:\\n logging.info('Extracting atomic poitions')\\n\\n # Extract coordinates from liggghts\\n self.lmp.command('variable x atom x')\\n x = Rxn.lmp.extract_variable(\\\"x\\\", \\\"group1\\\", 1)\\n\\n self.lmp.command('variable y atom y')\\n y = Rxn.lmp.extract_variable(\\\"y\\\", \\\"group1\\\", 1)\\n\\n self.lmp.command('variable z atom z')\\n z = Rxn.lmp.extract_variable(\\\"z\\\", \\\"group1\\\", 1)\\n\\n coords = np.zeros((self.lmp.get_natoms(),3))\\n\\n for i in range(self.lmp.get_natoms()):\\n coords[i,:] = x[i], y[i], z[i]\\n\\n self.lmp.command('variable x delete')\\n self.lmp.command('variable y delete')\\n self.lmp.command('variable z delete')\\n\\n return coords\",\n \"def box2pts(x1: int, y1: int, x2: int, y2: int) -> np.ndarray:\\n return np.array([[x1, y1], [x2, y1], [x2, y2], [x1, y2]])\",\n \"def linecut_points( **kwargs ):\\n npoints = kwargs.get('npoints', 320)\\n extents = kwargs.get('extents',None)\\n lims = kwargs.get('lims', (-80.,80.))\\n direc = kwargs.get('direc', (np.pi/2, 0.))\\n origin = kwargs.get('origin', vec3(0.,0.,0.))\\n\\n if extents is not None:\\n lims = (-extents, extents)\\n\\n # Prepare set of points for plot \\n t = np.linspace( lims[0], lims[1], npoints )\\n unit = vec3()\\n th = direc[0]\\n ph = direc[1] \\n unit.set_spherical(1, th, ph) \\n # Convert vec3s to ndarray\\n unit = np.array(unit)\\n origin = np.array(origin) \\n #\\n XYZ = origin + np.outer(t, unit)\\n X = XYZ[:,0]\\n Y = XYZ[:,1]\\n Z = XYZ[:,2]\\n \\n return t, X, Y, Z, lims\",\n \"def index_coords(data, origin=None):\\n ny, nx = data.shape[:2]\\n if origin is None:\\n origin_x, origin_y = nx // 2, ny // 2\\n else:\\n origin_x, origin_y = origin\\n x, y = np.meshgrid(np.arange(nx), np.arange(ny))\\n x -= origin_x\\n y -= origin_y\\n return x, y\",\n \"def get_points(self, npoints: int):\\n\\n R = sorted(np.random.rand(npoints) * 2. * np.pi)\\n\\n xx = self.cx + self.a * np.cos(R) * np.cos(self.angle_rad) - self.b * np.sin(R) * np.sin(\\n self.angle_rad)\\n\\n yy = self.cy + self.a * np.cos(R) * np.sin(self.angle_rad) + self.b * np.sin(R) * np.cos(\\n self.angle_rad)\\n\\n return R, xx, yy\",\n \"def get_random_points(N): \\n x1 = np.random.uniform(-1,1,N)\\n x2 = np.random.uniform(-1,1,N)\\n return (x1,x2)\",\n \"def coordinates(self):\",\n \"def get_coordinate_lists(self, crs=None):\\n x, y = self.vertices.vectors()[:2]\\n if crs is not None and (crs != self.crs):\\n x, y = _reproject((x,y), self.crs, crs)\\n return x, y\",\n \"def get_coordinates(self):\\n return np.array([(n.x, n.y) for n in self.nodes])\",\n \"def get_node_points(node):\\n for item in coordinate_list:\\n if item[0] == node.value:\\n return (item[1], item[2])\",\n \"def getNodeList(x, y, type):\\n\\t\\n\\tif type == 0:\\n\\t\\treturn pointListForGrass(x, y)\\n\\telif type == 1:\\n\\t\\treturn pointListForHorizontal(x, y)\\n\\telif type == 2:\\n\\t\\treturn pointListForVirticle(x, y)\\n\\telif type == 3:\\n\\t\\treturn pointListForT(x, y, type)\\n\\telif type == 4:\\n\\t\\treturn pointListForT(x, y, type)\\n\\telif type == 5:\\n\\t\\treturn pointListForT(x, y, type)\\n\\telif type == 6:\\n\\t\\treturn pointListForT(x, y, type)\\n\\telif type == 7:\\n\\t\\treturn pointListForPlus(x, y)\\n\\telif type == 8:\\n\\t\\treturn pointListForCurve(x, y, type)\\n\\telif type == 9:\\n\\t\\treturn pointListForCurve(x, y, type)\\n\\telif type == 10:\\n\\t\\treturn pointListForCurve(x, y, type)\\n\\telif type == 11:\\n\\t\\treturn pointListForCurve(x, y, type)\\n\\telse:\\n\\t\\treturn []\",\n \"def _getLatLonGrid(self, lats, lons):\\n numLats, numLons = lats.shape\\n\\n #coordGrid = [[0 for lon in range(numLons)] for lat in range(numLats)]\\n coordGrid = np.ndarray((numLats, numLons, 2))\\n for lat in range(len(lats)):\\n for lon in range(len(lons[lat])):\\n # Moved handling of pygrib version hack to _getIndex. Since the\\n # data matches up with the grid ordering given in lats and lons,\\n # we have to maintain that ordering in our created grid.\\n coordGrid[lat, lon, 0] = lats[lat][lon]\\n coordGrid[lat, lon, 1] = lons[lat][lon]\\n\\n\\n return coordGrid\",\n \"def g_xy(self):\\n for x in range(self.size.x):\\n for y in range(self.size.y):\\n yield self.p[0] + Vect(x, y)\",\n \"def get_2d_bb_points(bbox):\\n\\n cords = np.zeros((4, 4))\\n extent = bbox.extent\\n # arrange in clockwise to satisify the requirement in PyVisiLibity\\n cords[0, :] = np.array([extent.x, extent.y, 0, 1])\\n cords[1, :] = np.array([extent.x, -extent.y, 0, 1])\\n cords[2, :] = np.array([-extent.x, -extent.y, 0, 1])\\n cords[3, :] = np.array([-extent.x, extent.y, 0, 1])\\n\\n T_world = BboxUtils.get_matrix(carla.Transform(bbox.location, bbox.rotation))\\n world_cords = np.dot(T_world, np.transpose(cords))[:2, :]\\n return world_cords\",\n \"def xy(self):\\n ...\",\n \"def all_cells(self):\\n \\\"\\\"\\\"\\n Note that we use the convention that the first cell is (1,1)\\n \\\"\\\"\\\"\\n spart_star = self.circle_star()\\n part = Partition(list(spart_star))\\n coordinates = part.cells()\\n coordinates = [(x+1, y+1) for x, y in coordinates]\\n return coordinates\",\n \"def twoEntryPoints(self):\\n points = []\\n if self.isRed:\\n for x in range(self.midWidth, self.width):\\n for y in range(0, self.height):\\n if (x, y) not in self.walls:\\n adjacent = self.adjacentValidPoints(x, y)\\n if len(adjacent) == 2:\\n points.append((x, y))\\n else:\\n for x in range(0, self.midWidth-1):\\n for y in range(0, self.height):\\n if(x, y) not in self.walls:\\n adjacent = self.adjacentValidPoints(x, y)\\n if len(adjacent) == 2:\\n points.append((x, y))\\n return points\",\n \"def pointListForGrass(x, y):\\n\\n\\treturn []\\t# No points are made for grass\",\n \"def coordinates(self, mask):\\n y,x = mask.nonzero()\\n return list(zip(x,y))\",\n \"def get_topleft_coords(self, label):\\n return map(lambda coord: tuple(coord), self.coords[label])\",\n \"def getCartesianPoints2(r, theta, center):\\n x = r * np.cos(theta) + center[0]\\n y = r * np.sin(theta) + center[1]\\n\\n return x, y\",\n \"def get_neighbors(grid, x, y):\\n out = []\\n if x > 0:\\n out.append(grid[x-1, y])\\n if y > 0:\\n out.append(grid[x, y-1])\\n if y < grid.shape[1] - 1:\\n out.append(grid[x, y+1])\\n if x < grid.shape[0] - 1:\\n out.append(grid[x+1, y])\\n return out\",\n \"def cells(self):\\n \\\"\\\"\\\"\\n Note that we use the convention that the first cell is (1,1)\\n \\\"\\\"\\\"\\n spart_star = self.star()\\n part = Partition(list(spart_star))\\n coordinates = part.cells()\\n coordinates = [(x+1, y+1) for x, y in coordinates]\\n return coordinates\",\n \"def square(lattice_constant: float, number_of_rows: int, number_of_cols: int, starting_point: mp.Vector3) -> list:\\n lattice_sites = [starting_point]\\n lattice_vectors = (mp.Vector3(lattice_constant, 0),\\n mp.Vector3(0, lattice_constant))\\n\\n for col in range(number_of_cols):\\n for row in range(number_of_rows):\\n new_point = lattice_sites[row] + (lattice_vectors[1]) + col * (lattice_vectors[0])\\n lattice_sites.append(new_point)\\n new_point = lattice_sites[col] + (col * lattice_vectors[0]) - (col * lattice_vectors[1])\\n lattice_sites.append(new_point)\\n\\n return lattice_sites\",\n \"def lonlat(n_lon: int, n_lat: int) -> List[Tuple[float, float]]:\\n grid = []\\n for lon in np.linspace(0, 360.0 - 360.0 / n_lon, n_lon):\\n for lat in np.linspace(-90, 90, n_lat):\\n grid.append((lon, lat))\\n return grid\",\n \"def getXYZ(self, layout=None):\\n def mesh2d(xlim, ylim):\\n xx = [[xlim[0],xlim[1]],\\n [xlim[0],xlim[1]]]\\n yy = [[ylim[0],ylim[0]],\\n [ylim[1],ylim[1]]]\\n return xx,yy\\n def calc(x, y, z, normal, offset):\\n unknown = normal.dot(offset) - normal.vec[0]*x - normal.vec[1]*y - normal.vec[2]*z\\n return unknown\\n \\n xlim = [-1,1]\\n ylim = [-1,1]\\n zlim = [-1,1]\\n n = self.normal\\n off = self.offset\\n \\n if n.vec[2] == 0:\\n if n.vec[1] == 0:\\n if n.vec[0] == 0:\\n raise ValueError(\\\"Normal vector is zero vector.\\\")\\n else:\\n #cannot generate z or y but can x, try generating x for yz mesh\\n yy, zz = mesh2d(ylim, zlim)\\n xx = [[None,None],[None,None]]\\n for i in [0,1]:\\n for j in [0,1]:\\n xx[i][j] = calc(0, yy[i][j], zz[i][j], n, off)\\n else:\\n #cannot generate z but can y, try generating y for xz mesh\\n xx, zz = mesh2d(xlim, zlim)\\n yy = [[None,None],[None,None]]\\n for i in [0,1]:\\n for j in [0,1]:\\n yy[i][j] = calc(xx[i][j], 0, zz[i][j], n, off)\\n else:\\n #try generating z\\n xx, yy = mesh2d(xlim, ylim)\\n zz = [[None,None],[None,None]]\\n for i in [0,1]:\\n for j in [0,1]:\\n zz[i][j] = calc(xx[i][j], yy[i][j], 0, n, off)\\n return xx, yy, zz\",\n \"def coord (i, j):\\r\\n return j, i\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72631","0.66125095","0.65590817","0.64682907","0.6441065","0.6329514","0.6315307","0.6234959","0.61652595","0.6115704","0.61074376","0.6102117","0.6076739","0.6037446","0.60364854","0.60296583","0.6005677","0.6000581","0.5999192","0.5998226","0.5966211","0.59529614","0.5952564","0.59508336","0.59489995","0.593868","0.5932447","0.5930566","0.5917378","0.58997506","0.5894749","0.5883375","0.58677167","0.5865299","0.58574444","0.5845217","0.5819642","0.5813611","0.57938474","0.57910764","0.57857615","0.5779946","0.5774253","0.5774099","0.57658666","0.5756707","0.5749052","0.57424724","0.5722503","0.5721558","0.57175934","0.57081115","0.5705782","0.56974465","0.56952953","0.5691125","0.56814444","0.5667648","0.56655854","0.5664611","0.56606686","0.5659394","0.56470174","0.5640265","0.5626014","0.56205595","0.5614721","0.56123525","0.5610871","0.56095433","0.5607437","0.5607066","0.5596782","0.55914253","0.55893314","0.55810684","0.55792046","0.5577674","0.55772585","0.5573836","0.5570196","0.5568985","0.55647904","0.5561474","0.5555692","0.55529684","0.5549649","0.5545741","0.5531278","0.55284214","0.55209106","0.55189574","0.5518222","0.551629","0.5516185","0.55158144","0.5511896","0.55096895","0.5509312","0.55093074","0.5502994"],"string":"[\n \"0.72631\",\n \"0.66125095\",\n \"0.65590817\",\n \"0.64682907\",\n \"0.6441065\",\n \"0.6329514\",\n \"0.6315307\",\n \"0.6234959\",\n \"0.61652595\",\n \"0.6115704\",\n \"0.61074376\",\n \"0.6102117\",\n \"0.6076739\",\n \"0.6037446\",\n \"0.60364854\",\n \"0.60296583\",\n \"0.6005677\",\n \"0.6000581\",\n \"0.5999192\",\n \"0.5998226\",\n \"0.5966211\",\n \"0.59529614\",\n \"0.5952564\",\n \"0.59508336\",\n \"0.59489995\",\n \"0.593868\",\n \"0.5932447\",\n \"0.5930566\",\n \"0.5917378\",\n \"0.58997506\",\n \"0.5894749\",\n \"0.5883375\",\n \"0.58677167\",\n \"0.5865299\",\n \"0.58574444\",\n \"0.5845217\",\n \"0.5819642\",\n \"0.5813611\",\n \"0.57938474\",\n \"0.57910764\",\n \"0.57857615\",\n \"0.5779946\",\n \"0.5774253\",\n \"0.5774099\",\n \"0.57658666\",\n \"0.5756707\",\n \"0.5749052\",\n \"0.57424724\",\n \"0.5722503\",\n \"0.5721558\",\n \"0.57175934\",\n \"0.57081115\",\n \"0.5705782\",\n \"0.56974465\",\n \"0.56952953\",\n \"0.5691125\",\n \"0.56814444\",\n \"0.5667648\",\n \"0.56655854\",\n \"0.5664611\",\n \"0.56606686\",\n \"0.5659394\",\n \"0.56470174\",\n \"0.5640265\",\n \"0.5626014\",\n \"0.56205595\",\n \"0.5614721\",\n \"0.56123525\",\n \"0.5610871\",\n \"0.56095433\",\n \"0.5607437\",\n \"0.5607066\",\n \"0.5596782\",\n \"0.55914253\",\n \"0.55893314\",\n \"0.55810684\",\n \"0.55792046\",\n \"0.5577674\",\n \"0.55772585\",\n \"0.5573836\",\n \"0.5570196\",\n \"0.5568985\",\n \"0.55647904\",\n \"0.5561474\",\n \"0.5555692\",\n \"0.55529684\",\n \"0.5549649\",\n \"0.5545741\",\n \"0.5531278\",\n \"0.55284214\",\n \"0.55209106\",\n \"0.55189574\",\n \"0.5518222\",\n \"0.551629\",\n \"0.5516185\",\n \"0.55158144\",\n \"0.5511896\",\n \"0.55096895\",\n \"0.5509312\",\n \"0.55093074\",\n \"0.5502994\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24587,"cells":{"query":{"kind":"string","value":"Returns a list of flows with randomly selected sources and destinations that will saturate the network (i.e. a flow will be admitted provided that it would not cause the utilization of any link in the network to exceed 1. Flows are equally split across the K shortest paths connecting the source node to the destination node."},"document":{"kind":"string","value":"def compute_path_hopping_flow_allocations(target_graph, K=3):\n flow_allocation_seed_number = 0xCAFE_BABE\n np.random.seed(flow_allocation_seed_number)\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n link_utilization = {(u, v): 0.0 for u, v in target_graph.edges}\n node_capacity = {u: 0.0 for u in target_graph.nodes}\n flows = []\n while True:\n source_node, destination_node = flow_selection_fn(target_graph.nodes, 2, replace=False)\n print(source_node, destination_node)\n\n shortest_paths = sorted(nx.all_simple_paths(target_graph, source_node, destination_node,\n cutoff=3),\n key=lambda p: len(p))\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\n\n # flow_tx_rate = np.random.uniform() * 10\n flow_tx_rate = 1.0\n # if node_capacity[source_node] + flow_tx_rate > LINK_CAPACITY:\n # break\n node_capacity[source_node] += flow_tx_rate\n capacity_was_exceeded = False \n for path in [nx.utils.pairwise(p_i) for p_i in k_shortest_paths]:\n for u, v in [sorted(h_i) for h_i in path]:\n flow_rate_per_subpath = flow_tx_rate / K\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\n capacity_was_exceeded = True\n break\n link_utilization[u, v] += flow_rate_per_subpath\n if capacity_was_exceeded:\n break\n\n if capacity_was_exceeded:\n break\n\n the_flow = Flow( source_node = source_node\n , destination_node = destination_node\n , flow_tx_rate = flow_tx_rate\n , paths = k_shortest_paths\n , splitting_ratio = [1.0/K]*K\n )\n flows.append(the_flow)\n return flows, link_utilization"},"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 compute_equal_flow_allocations(target_graph, K=3):\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n flow_allocation_seed_number = 0xDEAD_BEEF\n np.random.seed(flow_allocation_seed_number)\n flows = []\n for node in target_graph.nodes:\n possible_destination_nodes = set(target_graph.nodes) - set([node])\n [destination_node] = np.random.choice(list(possible_destination_nodes), 1, replace=False)\n # shortest_paths = all_shortest_paths(target_graph, node, destination_node.item())\n shortest_paths = sorted(nx.all_simple_paths(target_graph, node, destination_node.item(),\n cutoff=3),\n key=lambda p: len(p))\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\n the_flow = Flow( source_node = node\n , destination_node = destination_node.item()\n , flow_tx_rate = 10.0\n , paths = k_shortest_paths\n , splitting_ratio = [1/K]*K\n )\n flows.append(the_flow)\n \n return flow_allocation_seed_number, flows","def bfsSample(G, source=None, k = 50):\n\twarn(\"networkit.sampling.bfsSample is deprecated, will be removed in future updates.\")\n\tif not source:\n\t\tsource = GraphTools.randomNode(G)\n\tn = G.numberOfNodes()\n\tvisited = [False]*n\n\tQ = [source]\n\tclosest = set([source])\n\tglobal found\n\tfound = 0\n\twhile len(Q) > 0 and found < k:\n\t\tu = Q.pop(0)\n\t\tdef enqueue(u,v,weight, eid):\n\t\t\tglobal found\n\t\t\tif not visited[v] and found < k:\n\t\t\t\tfound += 1\n\t\t\t\tvisited[v] = True\n\t\t\t\tQ.append(v)\n\t\t\t\tclosest.add(v)\n\t\tG.forEdgesOf(u, enqueue)\n\tprint(\"found {0} nodes\".format(len(closest)))\n\tG1 = GraphTools.subgraphFromNodes(G, closest)\n\treturn G1","def compute_greedy_flow_allocations( target_graph\n , flow_selection_fn\n , seed_number=DEFAULT_SEED_NUMBER):\n\n flow_allocation_seed_number = seed_number\n np.random.seed(flow_allocation_seed_number)\n\n link_utilization = {tuple(sorted(link_tuple)): 0.0 for link_tuple in target_graph.edges}\n flows = []\n\n while True:\n capacity_was_exceeded = False\n\n source_node, destination_node = flow_selection_fn(target_graph.nodes)\n flow_tx_rate = np.random.uniform(FLOW_TX_RATE_LOWER_BOUND, FLOW_TX_RATE_UPPER_BOUND)\n\n connecting_paths = list(node_disjoint_paths(target_graph, source_node, destination_node))\n disjoint_path_count = len(connecting_paths)\n flow_rate_per_subpath = flow_tx_rate / disjoint_path_count\n for path in [nx.utils.pairwise(p_i) for p_i in connecting_paths]:\n for u, v in [tuple(sorted(t_i)) for t_i in path]:\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\n capacity_was_exceeded = True\n break\n link_utilization[u, v] += flow_rate_per_subpath\n if capacity_was_exceeded:\n break\n if capacity_was_exceeded:\n break\n\n the_flow = Flow( source_node = source_node\n , destination_node = destination_node\n , flow_tx_rate = flow_tx_rate\n , paths = connecting_paths\n , splitting_ratio = [1.0/disjoint_path_count]*disjoint_path_count\n )\n flows.append(the_flow)\n return flows, link_utilization","def compute_unequal_flow_allocations(target_graph, K=3):\n\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n flow_allocation_seed_number = 0xDEAD_BEEF\n np.random.seed(flow_allocation_seed_number)\n flows = []\n link_utilization = {}\n for node in target_graph.nodes:\n possible_destination_nodes = set(target_graph.nodes) - {node}\n destination_node = np.random.choice(list(possible_destination_nodes), 1, \n replace=False).item()\n shortest_path = nx.shortest_path(target_graph, node, destination_node)\n the_flow = Flow( source_node = node\n , destination_node = destination_node\n , flow_tx_rate = 10.0\n , paths = [shortest_path]\n , splitting_ratio = [1.0]\n )\n flows.append(the_flow)\n\n return flow_allocation_seed_number, flows","def __generate_all_shortest_paths(self,cutoff = 10):\n if cutoff < 1:\n cutoff = 10\n self.__logger.info(\"cutoff value must be a positive integer. Set back to default value: 10\")\n\n all_pair_shortest_paths = nx.all_pairs_shortest_path(self.G, cutoff=cutoff)\n for item in all_pair_shortest_paths:\n from_node = item[0]\n paths = item[1]\n for destination,path in paths.items():\n yield (len(path),path)","def get_paths_for_flow(F, s, f):\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links","def get_paths_for_flow(F, s, f):\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links","def generate_graph(size, number_of_clusters, minimal_size):\n base_list = list(range(size))\n result_list = []\n random.shuffle(base_list)\n for i in range(number_of_clusters - 1):\n size = random.randint(minimal_size, len(base_list) - (number_of_clusters - i - 1) * minimal_size)\n cluster = []\n for n in range(size):\n actual = random.choice(base_list)\n base_list.remove(actual)\n cluster.append(actual)\n result_list.append(strongly_connect(cluster))\n result_list.append(strongly_connect(base_list))\n\n while len(result_list) < 5:\n result_list.append([])\n\n print(sorted([len(i) for i in result_list], reverse=True)[:5])\n\n return weak_connect_graph(result_list)","def get_pathologic_covering_routes(n_pl, n_target, attacker_strategy, target_values):\n # computes the coefficient used by the greedy oracle to choose routes\n targets_coeff = np.transpose(np.multiply(attacker_strategy, target_values))\n\n # randomly selects the player for which the non optimal choice will be made\n wrong_pl = randint(1, n_pl)\n\n # generate the non optimal route randomly\n n_covered_targets = randint(n_pl,n_target-1)\n non_opt_action = np.zeros(n_target)\n for i in range(0, n_covered_targets):\n random_covered_target = randint(0, n_target-1)\n non_opt_action[random_covered_target] = 1\n\n # compute the value of the non optimal route\n non_opt_val = get_value_single_route(non_opt_action, targets_coeff)\n\n # generate routes that have, as a single, values smaller than the best greedy route but taken togher perform\n # at least as well. [[0,1,...],[...],...] a[r][t]=1 iff t is covered by r.\n # The returned list should have n_pl - 1 routes\n opt_routes = get_opt_routes(n_pl, non_opt_action)\n\n I={}\n for pl in range(1, n_pl+1):\n\n n_r = randint(0, MAX_ROUTES)\n temp = lil_matrix((n_r+1, n_target), dtype='int8')\n\n if pl == wrong_pl:\n # put the non opt route in the bucket\n for t in non_opt_action.nonzero():\n temp[0,t] = 1\n else:\n for t in opt_routes.pop().nonzero():\n temp[0,t] = 1\n\n # generate other random routes with single value less than the non_opt_value\n for r in range(1, n_r):\n new_route = get_r_limited_val(non_opt_val, targets_coeff)\n\n for t in new_route.nonzero():\n temp[r,t] = 1\n\n I[pl] = temp.tocsr()\n\n return I","def multipleTravellingSalesmen(self, iterations=None):\n if not iterations:\n iterations = self.mTSPIterations\n\n # Randomly select points drawn from unvisited and distribute equally among the ships\n paths = self.partition(self.unvisited.keys(), len(self.ships))\n [path.append(ship) for path, ship in zip(paths, self.ships)]\n\n # Run single travelling salesman on each of the ships\n paths = [self.singleTravellingSalesman(path, iterations=0) for path in paths]\n\n\n # IF TWO OR MORE SHIPS!!!\n # Point exchange between ships and rerun tsp on each ship\n if len(self.ships) > 1:\n for _ in range(iterations):\n twopathindices = random.sample(xrange(len(paths)), 2)\n newtwopaths = self.swapTwoPointsBetweenPaths([paths[index] for index in twopathindices])\n newtwopaths = [self.singleTravellingSalesman(path, iterations=max(len(path), 100)) for path in\n newtwopaths]\n if self.totalPathDistance(newtwopaths) < self.totalPathDistance(\n [paths[index] for index in twopathindices]):\n for i, index in enumerate(twopathindices):\n paths[index] = newtwopaths[i]\n\n return paths","def set_random_session(self, G, degree_s):\n sorted_nodes = nx.topological_sort(G)\n num_nodes = G.number_of_nodes()\n\n # create sources and destinations of each of the sections\n # name the nodes to be the last 4 numbers\n srcs = [num_nodes, num_nodes + 1]\n dsts = [num_nodes + 2, num_nodes + 3]\n\n end_idx = int(0.3 * len(sorted_nodes))\n end_idx = max(end_idx, 2)\n for i in range(2):\n s = srcs[i]\n t = dsts[i]\n reachables = []\n iter_num = 0\n\n while len(reachables) == 0:\n iter_num += 1\n if iter_num > 100:\n end_idx = end_idx * 2\n\n # pick an entry point from the first 30%\n entry_point = random.choice(sorted_nodes[:end_idx])\n # print \"Source \", i\n # print \"candidates: \", sorted_nodes[:end_idx]\n # print \"entry point: \", entry_point\n # print \"all nodes: \", G.nodes()\n\n # pick a random point from the reachables\n reachables = nx.shortest_path(G, entry_point)\n del reachables[entry_point]\n #print \"reachables: \", reachables\n reachables = reachables.keys()\n\n exit_point = random.choice(reachables)\n #print \"exit_point: \", exit_point\n\n if degree_s[i]:\n G.add_edge(s, entry_point, weight=degree_s[i])\n G.add_edge(exit_point, t, weight=degree_s[i])\n else:\n # figure out the out_degree of entry point\n out_degree = np.sum(G[u][v]['weight'] for u,v in G.out_edges(entry_point))\n G.add_edge(s, entry_point, weight=out_degree)\n\n # figure out the int_degree of exit point\n in_degree = np.sum(G[u][v]['weight'] for u,v in G.in_edges(exit_point))\n G.add_edge(exit_point, t, weight=in_degree)\n\n edges = G.edges()\n for u, v in edges:\n par_num = int(G[u][v]['weight'])\n for i in range(par_num):\n self.add_edge(u, v)\n\n # set indices etc\n self.set_sources(srcs)\n self.set_destinations(dsts)\n self.set_indices()\n #print \"number of nodes: \" + str(self.number_of_nodes())\n #print \"number of edges: \" + str(self.number_of_edges())","def get_k_shortest_paths(env: RailEnv,\n source_position: Tuple[int, int],\n source_direction: int,\n target_position=Tuple[int, int],\n k: int = 1, debug=False) -> List[Tuple[Waypoint]]:\n\n # P: set of shortest paths from s to t\n # P =empty,\n shortest_paths: List[Tuple[Waypoint]] = []\n\n # countu: number of shortest paths found to node u\n # countu = 0, for all u in V\n count = {(r, c, d): 0 for r in range(env.height) for c in range(env.width) for d in range(4)}\n\n # B is a heap data structure containing paths\n # N.B. use OrderedSet to make result deterministic!\n heap: OrderedSet[Tuple[Waypoint]] = OrderedSet()\n\n # insert path Ps = {s} into B with cost 0\n heap.add((Waypoint(source_position, source_direction),))\n\n # while B is not empty and countt < K:\n while len(heap) > 0 and len(shortest_paths) < k:\n if debug:\n print(\"iteration heap={}, shortest_paths={}\".format(heap, shortest_paths))\n # – let Pu be the shortest cost path in B with cost C\n cost = np.inf\n pu = None\n for path in heap:\n if len(path) < cost:\n pu = path\n cost = len(path)\n u: Waypoint = pu[-1]\n if debug:\n print(\" looking at pu={}\".format(pu))\n\n # – B = B − {Pu }\n heap.remove(pu)\n # – countu = countu + 1\n\n urcd = (*u.position, u.direction)\n count[urcd] += 1\n\n # – if u = t then P = P U {Pu}\n if u.position == target_position:\n if debug:\n print(\" found of length {} {}\".format(len(pu), pu))\n shortest_paths.append(pu)\n\n # – if countu ≤ K then\n # CAVEAT: do not allow for loopy paths\n elif count[urcd] <= k:\n possible_transitions = env.rail.get_transitions(*urcd)\n if debug:\n print(\" looking at neighbors of u={}, transitions are {}\".format(u, possible_transitions))\n # for each vertex v adjacent to u:\n for new_direction in range(4):\n if debug:\n print(\" looking at new_direction={}\".format(new_direction))\n if possible_transitions[new_direction]:\n new_position = get_new_position(u.position, new_direction)\n if debug:\n print(\" looking at neighbor v={}\".format((*new_position, new_direction)))\n\n v = Waypoint(position=new_position, direction=new_direction)\n # CAVEAT: do not allow for loopy paths\n if v in pu:\n continue\n\n # – let Pv be a new path with cost C + w(u, v) formed by concatenating edge (u, v) to path Pu\n pv = pu + (v,)\n # – insert Pv into B\n heap.add(pv)\n\n # return P\n return shortest_paths","def stochastic_event_set(\n sources, source_site_filter=filters.source_site_noop_filter):\n for source, s_sites in source_site_filter(sources):\n try:\n for rupture in source.iter_ruptures():\n for i in range(rupture.sample_number_of_occurrences()):\n yield rupture\n except Exception as err:\n etype, err, tb = sys.exc_info()\n msg = 'An error occurred with source id=%s. Error: %s'\n msg %= (source.source_id, str(err))\n raise_(etype, msg, tb)","def ford_fulkerson_algorithm(graph: np.ndarray, source: int, sink: int) -> np.ndarray:\r\n\r\n residual_graph = copy.deepcopy(graph)\r\n row = len(residual_graph)\r\n parent = [-1] * row\r\n max_flow = 0\r\n\r\n if source == sink or sink < 0 or source < 0 or source >= row or sink >= row:\r\n raise WrongInputException('Wrong input source/sink vertice(s)')\r\n\r\n while bfs(residual_graph, row, source, sink, parent):\r\n\r\n path_flow = float(\"Inf\")\r\n s = sink\r\n while s != source:\r\n path_flow = min(path_flow, residual_graph[parent[s]][s])\r\n s = parent[s]\r\n\r\n max_flow += path_flow\r\n\r\n v = sink\r\n while v != source:\r\n u = parent[v]\r\n residual_graph[u][v] -= path_flow\r\n residual_graph[v][u] += path_flow\r\n v = parent[v]\r\n print(\"Max flow: %d\" % max_flow)\r\n\r\n return residual_graph","def run_random_annealing(tsp_file, T, scheme, N_sim, max_chain_length=100000, c=.95):\n # create empty lists for to be stored values\n best_routes, costs, cost_lists = [], [], []\n\n adjacency_matrix = make_matrix(tsp_file)\n\n for _ in range(N_sim):\n # generate random initial route\n x = list(range(len(adjacency_matrix)))\n init_route = random.sample(x,len(x))\n \n # find best route with SA algorithm\n best_route, cost_list = tsp_annealing_random(T, scheme, init_route, adjacency_matrix, max_chain_length, c)\n\n # append all values from simulation to lists\n costs.append(calculate_cost(best_route,adjacency_matrix)[1])\n best_routes.append(best_route)\n cost_lists.append(cost_list)\n\n return best_routes, costs, cost_lists","def k_shortest_paths(G, source, target, k=1, weight='weight'):\n\tif source == target:\n\t\treturn ([0], [[source]]) \n\t \n\tlength, path = nx.single_source_dijkstra(G, source, target, weight=weight)\n\tif target not in length:\n\t\traise nx.NetworkXNoPath(\"node %s not reachable from %s\" % (source, target))\n\t\t\n\tlengths = [length[target]]\n\tpaths = [path[target]]\n\tc = count()\t\t\n\tB = []\t\t\t\t\t\t\n\tG_original = G.copy()\t\n\t\n\tfor i in range(1, k):\n\t\tfor j in range(len(paths[-1]) - 1):\t\t\t\n\t\t\tspur_node = paths[-1][j]\n\t\t\troot_path = paths[-1][:j + 1]\n\t\t\t\n\t\t\tedges_removed = []\n\t\t\tfor c_path in paths:\n\t\t\t\tif len(c_path) > j and root_path == c_path[:j + 1]:\n\t\t\t\t\tu = c_path[j]\n\t\t\t\t\tv = c_path[j + 1]\n\t\t\t\t\tif G.has_edge(u, v):\n\t\t\t\t\t\tedge_attr = G.edge[u][v]\n\t\t\t\t\t\tG.remove_edge(u, v)\n\t\t\t\t\t\tedges_removed.append((u, v, edge_attr))\n\t\t\t\n\t\t\tfor n in range(len(root_path) - 1):\n\t\t\t\tnode = root_path[n]\n\t\t\t\t# out-edges\n\t\t\t\tfor u, v, edge_attr in G.copy().edges_iter(node, data=True):\n\t\t\t\t\tG.remove_edge(u, v)\n\t\t\t\t\tedges_removed.append((u, v, edge_attr))\n\t\t\t\t\n\t\t\t\tif G.is_directed():\n\t\t\t\t\t# in-edges\n\t\t\t\t\tfor u, v, edge_attr in G.in_edges_iter(node, data=True):\n\t\t\t\t\t\tG.remove_edge(u, v)\n\t\t\t\t\t\tedges_removed.append((u, v, edge_attr))\n\t\t\t\n\t\t\tspur_path_length, spur_path = nx.single_source_dijkstra(G, spur_node, target, weight=weight)\t\t\t\n\t\t\tif target in spur_path and spur_path[target]:\n\t\t\t\ttotal_path = root_path[:-1] + spur_path[target]\n\t\t\t\ttotal_path_length = get_path_length(G_original, root_path, weight) + spur_path_length[target]\t\t\t\t\n\t\t\t\theappush(B, (total_path_length, next(c), total_path))\n\t\t\t\t\n\t\t\tfor e in edges_removed:\n\t\t\t\tu, v, edge_attr = e\n\t\t\t\tG.add_edge(u, v, edge_attr)\n\t\t\t\t\t \n\t\tif B:\n\t\t\t(l, _, p) = heappop(B)\n\t\t\tlengths.append(l)\n\t\t\tpaths.append(p)\n\t\telse:\n\t\t\tbreak\n\t\n\treturn (lengths, paths)","def k_shortest_paths(G, source, target, k=1, weight='weight'):\n\tif source == target:\n\t\treturn ([0], [[source]]) \n\t \n\tlength, path = nx.single_source_dijkstra(G, source, target, weight=weight)\n\tif target not in length:\n\t\traise nx.NetworkXNoPath(\"node %s not reachable from %s\" % (source, target))\n\t\t\n\tlengths = [length[target]]\n\tpaths = [path[target]]\n\tc = count()\t\t\n\tB = []\t\t\t\t\t\t\n\tG_original = G.copy()\t\n\t\n\tfor i in range(1, k):\n\t\tfor j in range(len(paths[-1]) - 1):\t\t\t\n\t\t\tspur_node = paths[-1][j]\n\t\t\troot_path = paths[-1][:j + 1]\n\t\t\t\n\t\t\tedges_removed = []\n\t\t\tfor c_path in paths:\n\t\t\t\tif len(c_path) > j and root_path == c_path[:j + 1]:\n\t\t\t\t\tu = c_path[j]\n\t\t\t\t\tv = c_path[j + 1]\n\t\t\t\t\tif G.has_edge(u, v):\n\t\t\t\t\t\tedge_attr = G.edge[u][v]\n\t\t\t\t\t\tG.remove_edge(u, v)\n\t\t\t\t\t\tedges_removed.append((u, v, edge_attr))\n\t\t\t\n\t\t\tfor n in range(len(root_path) - 1):\n\t\t\t\tnode = root_path[n]\n\t\t\t\t# out-edges\n\t\t\t\tfor u, v, edge_attr in G.copy().edges_iter(node, data=True):\n\t\t\t\t\tG.remove_edge(u, v)\n\t\t\t\t\tedges_removed.append((u, v, edge_attr))\n\t\t\t\t\n\t\t\t\tif G.is_directed():\n\t\t\t\t\t# in-edges\n\t\t\t\t\tfor u, v, edge_attr in G.in_edges_iter(node, data=True):\n\t\t\t\t\t\tG.remove_edge(u, v)\n\t\t\t\t\t\tedges_removed.append((u, v, edge_attr))\n\t\t\t\n\t\t\tspur_path_length, spur_path = nx.single_source_dijkstra(G, spur_node, target, weight=weight)\t\t\t\n\t\t\tif target in spur_path and spur_path[target]:\n\t\t\t\ttotal_path = root_path[:-1] + spur_path[target]\n\t\t\t\ttotal_path_length = get_path_length(G_original, root_path, weight) + spur_path_length[target]\t\t\t\t\n\t\t\t\theappush(B, (total_path_length, next(c), total_path))\n\t\t\t\t\n\t\t\tfor e in edges_removed:\n\t\t\t\tu, v, edge_attr = e\n\t\t\t\tG.add_edge(u, v, edge_attr)\n\t\t\t\t\t \n\t\tif B:\n\t\t\t(l, _, p) = heappop(B)\t\t\n\t\t\tlengths.append(l)\n\t\t\tpaths.append(p)\n\t\telse:\n\t\t\tbreak\n\t\n\treturn (lengths, paths)","def _select_destination(self):\n # Ideally this should do something clever based on the start location\n # ie known trips. But for now, it will pick randomly!\n station_dict = self.network.station_dict\n\n stations = list(station_dict.keys())\n #stations = [x for x in stations if isinstance(x, int) or x.startswith(\"801\")]\n #stations = [x for x in stations if isinstance(x, int) or x.startswith(\"80139\")]\n weights = [station_dict[x].in_popularity for x in stations]\n\n # pick using the given weight distributions\n self.dest = random.choices(stations, weights=weights)[0]\n\n return","def possible(self):\n return [tuple(path) for path in nx.all_shortest_paths(self._gpm.Graph, source=self.source, target=self.target)]","def test_sources():\n g = Graph(from_list=[\n (1, 3, 1),\n (2, 4, 1),\n (2, 5, 1),\n (3, 5, 1),\n (4, 6, 1),\n (5, 6, 1),\n ])\n g.add_node(7)\n s = g.sources(5)\n e = {1, 2, 3}\n assert s == e\n\n s2 = g.sources(1)\n e2 = set()\n assert s2 == e2, s2\n\n s3 = g.sources(6)\n e3 = {1, 2, 3, 4, 5}\n assert s3 == e3\n\n s4 = g.sources(7)\n e4 = set()\n assert s4 == e4","def test_heuristic_first_steps(self):\n graph = {n: set(self.deterministic_graph[n]) - set([n])\n for n in self.deterministic_graph}\n deg_heuristic = MinDegreeHeuristic(graph)\n elim_node = deg_heuristic.best_node(graph)\n print(\"Graph {}:\".format(graph))\n steps = []\n\n while elim_node is not None:\n print(\"Removing {}:\".format(elim_node))\n steps.append(elim_node)\n nbrs = graph[elim_node]\n\n for u, v in itertools.permutations(nbrs, 2):\n if v not in graph[u]:\n graph[u].add(v)\n\n for u in graph:\n if elim_node in graph[u]:\n graph[u].remove(elim_node)\n\n del graph[elim_node]\n print(\"Graph {}:\".format(graph))\n elim_node = deg_heuristic.best_node(graph)\n\n # check only the first 5 elements for equality\n assert_equals(steps[:5], [0, 1, 2, 3, 4])","def get_routing_solution(self):\n G = self.base_digraph\n s1 = self.sources[0]\n s2 = self.sources[1]\n t1 = self.destinations[0]\n t2 = self.destinations[1]\n\n try:\n m = Model('routing')\n m.setParam('OutputFlag', False)\n\n # variables,\n # We have one variable per edge per session\n # e is the dict of dict for the variables\n e = {}\n r = {}\n for i in [1,2]:\n e[i] = {}\n r[i] = m.addVar()\n for u,v in G.edges():\n e[i][u,v] = m.addVar(lb=0)\n\n m.update()\n\n obj = quicksum(r.values())\n m.setObjective(obj, GRB.MAXIMIZE)\n\n # constraints\n # 1. conservations of flow at all intermediate nodes\n # 2. capacity constraints for each edge\n\n for u,v in G.edges():\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\n\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\n\n for n in G.nodes():\n if n not in [s1, s2, t1, t2]:\n for i in [1, 2]:\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\n m.addConstr(inflow == outflow)\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n for u, v in G.edges():\n G[u][v]['Routing'] = {}\n G[u][v]['Routing'][1] = e[1][u,v].x\n G[u][v]['Routing'][2] = e[2][u,v].x\n return (m.objVal, r[1].x, r[2].x)\n else:\n # something went wrong...err...\n print \"Something was wrong, no optimal solution obtained\"\n return None, None, None\n\n except GurobiError:\n Print ('Error Report from Gurobi')","def sampled_clique(clusters,strategy):\n G = nx.Graph()\n sample = []\n #Sample 'size' nodes from a single cluster\n if strategy == \"rand\":\n size = len(clusters)\n while len(sample) < size:\n cluster = random.choice(clusters)\n if len(cluster) >= size:\n sample = random.sample(cluster,size)\n #Sample 1 choice from each cluster\n elif strategy == \"optim\":\n for _,cluster in clusters.items():\n if len(cluster) > 0:\n sample.append(random.choice(cluster))\n for n1 in sample:\n for n2 in sample:\n if n1 != n2:\n G.add_edge(n1,n2)\n return G","def random_partition_graph(groups, p_in, p_out, seed=None):\r\n\r\n if p_in > 1 or p_in < 0:\r\n raise errorhandler.ErrorHandler(\"p_in must be in [0,1]\")\r\n\r\n if p_out > 1 or p_out < 0:\r\n raise errorhandler.ErrorHandler(\"p_out must be in [0,1]\")\r\n\r\n size = sum(groups)\r\n g = graph.Graph(size, is_partition=True)\r\n\r\n next_group = {}\r\n start = 0\r\n group_index = 0\r\n for n in groups: # connect nodes inside a group\r\n edges = ((u + start, v + start) for u, v in fast_random_graph(n, p_in).edges)\r\n g.add_edges(edges)\r\n g.partition.append(set(range(start, start+n)))\r\n next_group.update(dict.fromkeys(range(start, start + n), start + n))\r\n group_index += 1\r\n start += n\r\n\r\n # connect nodes between groups\r\n if p_out == 0:\r\n return g\r\n if p_out == 1:\r\n for n in next_group:\r\n targets = range(next_group[n], len(g))\r\n g.add_edges(zip([n] * len(targets), targets))\r\n return g\r\n\r\n # using method similar to fast_random_graph\r\n lp = math.log(1.0 - p_out)\r\n n = len(g)\r\n\r\n for u in range(n - 1):\r\n v = next_group[u]\r\n while v < n:\r\n lr = math.log(1.0 - random.random())\r\n v += int(lr / lp)\r\n if v < n:\r\n g.add_edge(u, v)\r\n v += 1\r\n\r\n return g","def k_shortest_paths(\n self,\n G,\n source,\n target,\n k=1,\n weight='weight',\n ):\n\n if source == target:\n return ([0], [[source]])\n\n (length, path) = nx.single_source_dijkstra(G, source, target,\n weight=weight)\n if target not in length:\n raise nx.NetworkXNoPath('node %s not reachable from %s' % (source,\n target))\n\n lengths = [length[target]]\n paths = [path[target]]\n c = count()\n B = []\n\n # Is deep copy really required?\n # Fails due to embedded Ctype objects which can not be pickled\n # # G_original = G.copy()\n # Swapping with shallow copy...will it work?\n\n G_original = G\n if nx.is_directed(G_original):\n G = nx.DiGraph(G_original)\n else:\n G = nx.Graph(G_original)\n\n ######################################\n #TODO: wrap this up somehow\n print ''\n print term.move_up + term.move_up\n ######################################\n print 'getting K:{} paths...'.format(k),\n for i in range(1, k):\n with term.location():\n print i\n for j in range(len(paths[-1]) - 1):\n spur_node = paths[-1][j]\n root_path = (paths[-1])[:j + 1]\n\n edges_removed = []\n for c_path in paths:\n if len(c_path) > j and root_path == c_path[:j + 1]:\n u = c_path[j]\n v = c_path[j + 1]\n if G.has_edge(u, v):\n edge_attr = G.edge[u][v]\n G.remove_edge(u, v)\n edges_removed.append((u, v, edge_attr))\n\n for n in range(len(root_path) - 1):\n node = root_path[n]\n\n # out-edges\n\n for (u, v, edge_attr) in G.edges_iter(node, data=True):\n\n # print 'lala1: {} -> {}'.format(u,v)\n\n G.remove_edge(u, v)\n edges_removed.append((u, v, edge_attr))\n\n if G.is_directed():\n\n # in-edges\n\n for (u, v, edge_attr) in G.in_edges_iter(node,\n data=True):\n\n # print 'lala2: {} -> {}'.format(u,v)\n\n G.remove_edge(u, v)\n edges_removed.append((u, v, edge_attr))\n\n (spur_path_length, spur_path) = nx.single_source_dijkstra(G,\n spur_node, target, weight=weight)\n if target in spur_path and spur_path[target]:\n total_path = root_path[:-1] + spur_path[target]\n total_path_length = self.get_path_length(G_original,\n root_path, weight) + spur_path_length[target]\n heappush(B, (total_path_length, next(c), total_path))\n\n for e in edges_removed:\n (u, v, edge_attr) = e\n G.add_edge(u, v, edge_attr)\n\n if B:\n (l, _, p) = heappop(B)\n lengths.append(l)\n paths.append(p)\n else:\n break\n\n return (lengths, paths)","def search_shortest_paths(\n self,\n src_nodes: list[TN],\n dst_node: TN,\n operation_src: str,\n operation_dest: str,\n domain: str,\n limit_dest_schemes: list[str],\n *,\n session: \"Session\",\n ) -> dict[TN, list[dict[str, Any]]]:\n\n for rse in itertools.chain(src_nodes, [dst_node], self._multihop_nodes):\n rse.ensure_loaded(load_attributes=True, load_info=True, session=session)\n self.ensure_edges_loaded(session=session)\n\n if self._multihop_nodes:\n # Filter out island source RSEs\n nodes_to_find = {node for node in src_nodes if node.out_edges}\n else:\n nodes_to_find = set(src_nodes)\n\n class _NodeStateProvider:\n _hop_penalty = self._hop_penalty\n\n def __init__(self, node: TN):\n self.enabled: bool = True\n self.cost: _Number = 0\n if node != dst_node:\n try:\n self.cost = int(node.attributes.get('hop_penalty', self._hop_penalty))\n except ValueError:\n self.cost = self._hop_penalty\n\n scheme_missmatch_found = {}\n\n class _EdgeStateProvider:\n def __init__(self, edge: TE):\n self.edge = edge\n self.chosen_scheme = {}\n\n @property\n def cost(self) -> _Number:\n return self.edge.cost\n\n @property\n def enabled(self) -> bool:\n try:\n matching_scheme = rsemgr.find_matching_scheme(\n rse_settings_src=self.edge.src_node.info,\n rse_settings_dest=self.edge.dst_node.info,\n operation_src=operation_src,\n operation_dest=operation_dest,\n domain=domain,\n scheme=limit_dest_schemes if self.edge.dst_node == dst_node and limit_dest_schemes else None,\n )\n self.chosen_scheme = {\n 'source_scheme': matching_scheme[1],\n 'dest_scheme': matching_scheme[0],\n 'source_scheme_priority': matching_scheme[3],\n 'dest_scheme_priority': matching_scheme[2],\n }\n return True\n except RSEProtocolNotSupported:\n scheme_missmatch_found[self.edge.src_node] = True\n return False\n\n paths = {dst_node: []}\n for node, distance, _, edge_to_next_hop, edge_state in self.dijkstra_spf(dst_node=dst_node,\n nodes_to_find=nodes_to_find,\n node_state_provider=_NodeStateProvider,\n edge_state_provider=_EdgeStateProvider):\n nh_node = edge_to_next_hop.dst_node\n edge_state = cast(_EdgeStateProvider, edge_state)\n hop = {\n 'source_rse': node,\n 'dest_rse': nh_node,\n 'hop_distance': edge_state.cost,\n 'cumulated_distance': distance,\n **edge_state.chosen_scheme,\n }\n paths[node] = [hop] + paths[nh_node]\n\n nodes_to_find.discard(node)\n if not nodes_to_find:\n # We found the shortest paths to all desired nodes\n break\n\n result = {}\n for node in src_nodes:\n path = paths.get(node)\n if path is not None:\n result[node] = path\n elif scheme_missmatch_found.get(node):\n result[node] = []\n return result","def _dfs(\n self, kg: KG, entity: Vertex, is_reverse: bool = False\n ) -> List[Walk]:\n self.sampler.visited = set()\n walks: List[Walk] = []\n assert self.max_walks is not None\n\n rng = np.random.RandomState(self.random_state)\n\n while len(walks) < self.max_walks:\n sub_walk: Walk = (entity,)\n d = 1\n while d // 2 < self.max_depth:\n pred_obj = self.sampler.sample_hop(\n kg, sub_walk, d // 2 == self.max_depth - 1, is_reverse\n )\n if pred_obj is None:\n break\n\n if is_reverse:\n if (\n pred_obj[0] in self.communities\n and rng.random() < self.hop_prob\n ):\n community_nodes = self.labels_per_community[\n self.communities[pred_obj[0]]\n ]\n sub_walk = (\n pred_obj[1],\n rng.choice(community_nodes),\n ) + sub_walk\n else:\n sub_walk = (pred_obj[1], pred_obj[0]) + sub_walk\n else:\n if (\n pred_obj[1] in self.communities\n and rng.random() < self.hop_prob\n ):\n community_nodes = self.labels_per_community[\n self.communities[pred_obj[1]]\n ]\n sub_walk += (\n pred_obj[0],\n rng.choice(community_nodes),\n )\n else:\n sub_walk += (pred_obj[0], pred_obj[1])\n d = len(sub_walk) - 1\n walks.append(sub_walk)\n return list(walks)","def test_heuristic_first_steps(self):\n graph = {n: set(self.deterministic_graph[n]) - set([n])\n for n in self.deterministic_graph}\n print(\"Graph {}:\".format(graph))\n elim_node = min_fill_in_heuristic(graph)\n steps = []\n\n while elim_node is not None:\n print(\"Removing {}:\".format(elim_node))\n steps.append(elim_node)\n nbrs = graph[elim_node]\n\n for u, v in itertools.permutations(nbrs, 2):\n if v not in graph[u]:\n graph[u].add(v)\n\n for u in graph:\n if elim_node in graph[u]:\n graph[u].remove(elim_node)\n\n del graph[elim_node]\n print(\"Graph {}:\".format(graph))\n elim_node = min_fill_in_heuristic(graph)\n\n # check only the first 2 elements for equality\n assert_equals(steps[:2], [6, 5])","def get_all_pairs(G):\n # list all (start,dest) pairs between which the route must be computed\n pairs_list = [(start, dest) for dest in G.nodes for start in G.nodes]\n\n # shuffle all elements in-place\n random.shuffle(pairs_list)\n\n # generate a set from the list\n pairs_set = set(pairs_list)\n\n return pairs_list, pairs_set","def multipleTravellingSalesmen2(self, iterations=None):\n if not iterations:\n iterations = self.mTSPIterations\n\n paths, self.totaldistanceMTSP = self.greedyMultiplePaths(self.ships)\n\n # Run single travelling salesman on each of the ships\n paths = [self.singleTravellingSalesman2(path, iterations=5000) for path in paths]\n\n # IF TWO OR MORE SHIPS!!!\n # Point exchange between ships and rerun tsp on each ship\n if len(self.ships) > 1:\n for _ in range(iterations):\n twopathindices = random.sample(xrange(len(paths)), 2)\n if min([len(path) for path in paths]) > 1:\n newtwopaths = self.swapTwoPointsBetweenPaths([paths[index] for index in twopathindices])\n newtwopaths = [self.singleTravellingSalesman2(path, iterations=100) for path in newtwopaths]\n if self.totalPathDistance(newtwopaths) < self.totalPathDistance([paths[index] for index in twopathindices]):\n for i, index in enumerate(twopathindices):\n paths[index] = newtwopaths[i]\n\n return [path[::-1] for path in paths]\n\n # Might be a simple tsp whereby the new points search for the twp closest points and\n # inserts between them on the path","def shiftFlows(self, targetFlows, stepSize):\n for l in self.link:\n current = self.link[l].flow\n target = targetFlows[l]\n new = current *(1 - stepSize)+target*stepSize\n self.link[l].flow = new\n self.link[l].updateCost()","def max_flow(self, source, sink):\n\n path = self.valid_path(source, sink, [])\n\n while path:\n # get the maximum possible flow that can be taken from this path:\n max_flow = min([edge.capacity for edge in path])\n for edge in path:\n self.edges[edge] += max_flow\n path = self.valid_path(source, sink, [])\n\n # Compute all the flows from the neighbors of source:\n return sum([self.edges[edge] for edge in self.adjacents[source]])","def generate_pairs(self, all_walks):\n logging.info(['edge_types before generate pairs', self.edge_types])\n\n pairs = []\n skip_window = self.config['win_size'] // 2\n for layer_id, e_type in enumerate(self.edge_types):\n walks = all_walks[e_type]\n for walk in tqdm.tqdm(walks):\n for i in range(len(walk)):\n for j in range(1, skip_window + 1):\n if i - j >= 0 and walk[i] != walk[i - j]:\n neg_nodes = self.graph[e_type].sample_nodes(\n self.config['neg_num'])\n pairs.append(\n (walk[i], walk[i - j], *neg_nodes, layer_id))\n if i + j < len(walk) and walk[i] != walk[i + j]:\n neg_nodes = self.graph[e_type].sample_nodes(\n self.config['neg_num'])\n pairs.append(\n (walk[i], walk[i + j], *neg_nodes, layer_id))\n return pairs","def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\n demand: float,\n routing: np.ndarray) -> np.ndarray:\n edge_mapping = {edge: i for i, edge in\n enumerate(sorted(self.graph.edges))}\n\n link_utilisation = np.zeros(self.num_edges)\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\n node_flow[flow[0]] = demand\n\n to_explore = [flow[0]]\n while to_explore:\n current_node = to_explore.pop(0)\n current_flow = node_flow[current_node]\n\n # this is the flow destination node so we absorb all flow\n if current_node == flow[1]:\n node_flow[current_node] = 0.0\n continue\n\n # push the flow at this node over all edges\n for edge in self.graph.out_edges(current_node):\n edge_index = edge_mapping[edge]\n ratio = routing[edge_index]\n flow_to_send = ratio * current_flow\n # only send flow if greater than epsilon (so no 'infinite' loops)\n if flow_to_send > 1.e-8:\n node_flow[edge[1]] += ratio * current_flow\n # all important step, update our output\n link_utilisation[edge_index] += ratio * current_flow\n # have updated the dst so add it to the list of things to do\n to_explore.append(edge[1])\n # we've moved all the flow from this node now, so reset back to zero\n node_flow[current_node] = 0.0\n\n return link_utilisation","def tsp_annealing_random(T, scheme, route, adjacency_matrix, max_chain_length,c):\n best = route.copy()\n chains = 0\n cost_list = []\n T_0 = T\n T_list = []\n \n while T > 0:\n # Sample city from route\n temp = route.copy()\n index1, index2 = np.random.randint(1,len(best)-1,size=2)\n\n sd, cost0 = calculate_cost(route,adjacency_matrix)\n cost_list.append(cost0)\n\n temp[index1:index2] = temp[index2-1:index1-1:-1]\n _, cost1 = calculate_cost(temp,adjacency_matrix)\n\n chains += 1\n T_list.append(T)\n\n # Adjust temperature\n if scheme == \"exp\":\n T = T*c\n if scheme == \"log\":\n alpha = 50\n T = T_0/(1+alpha*np.log(1+chains))\n if scheme == \"std\":\n delta = .1\n T = T / (1 + ((np.log(1+delta)* T) / (3 * sd)))\n if scheme == \"quad\":\n alpha = 1\n T = T_0/(1+alpha*chains**2)\n\n # Metropolis step \n if cost0 > cost1:\n route = temp.copy()\n else:\n U = rs.uniform()\n if U < np.exp((cost0-cost1)/T):\n route = temp.copy()\n\n best = route.copy()\n if chains > max_chain_length:\n return best, cost_list\n return best, cost_list","def objective(graph, flows):\n\n G = graph.copy()\n rules = {}\n flows.sort(key=lambda a: a[1], reverse=True)\n\n for flow,demand in flows:\n src = get_host_from_ip(G, flow.nw_src)\n dst = get_host_from_ip(G, flow.nw_dst)\n\n if not (src and dst):\n continue\n if not (src in G.nodes() and dst in G.nodes()):\n continue\n\n path = widest_path(G, src, dst)\n\n hops = []\n for a,b in pairwise(path):\n hops.append(Hop(dpid=int(a[1:]), port=G.edge[a][b]['port']))\n G.edge[a][b]['capacity'] -= demand\n G.edge[b][a]['capacity'] -= demand\n\n rules[flow] = hops\n\n return rules","def getShortestPath(self, src, dest):\n vertices = self.floorGraph.getVertList()\n unvisitedQueue = []\n srcPath = Path()\n srcPath.addNode(src)\n srcPath.pathValue = 0\n unvisitedQueue.append(srcPath)\n connections = self.floorGraph.getVertex(src).getConnections()\n #initialisez distances\n for vertex in vertices:\n newPath = Path()\n newPath.nodeList = list(srcPath.nodeList)\n newPath.addNode(vertex)\n if self.floorGraph.getVertex(vertex) in connections:\n newPath.pathValue = self.floorGraph.getVertex(src).getWeight(self.floorGraph.getVertex(vertex))\n unvisitedQueue.append(newPath)\n else:\n newPath.pathValue = math.inf\n self.shortestDistanceMap[src+vertex] = newPath\n # updates distances as per shorter routes\n while len(unvisitedQueue) is not 0:\n unvisitedQueue = sorted(unvisitedQueue, key=functools.cmp_to_key(compareNodes))\n chkPath = unvisitedQueue.pop(0)\n chkNode = chkPath.nodeList[len(chkPath.nodeList)-1]\n for vertex in vertices:\n if(self.floorGraph.getVertex(vertex) in self.floorGraph.getVertex(chkNode).getConnections()):\n newWeight = chkPath.pathValue + self.floorGraph.getVertex(chkNode).getWeight(self.floorGraph.getVertex(vertex))\n if(newWeight < self.shortestDistanceMap[src+vertex].pathValue):\n self.shortestDistanceMap[src+vertex].pathValue = newWeight\n self.shortestDistanceMap[src+vertex].nodeList = list(chkPath.nodeList)\n self.shortestDistanceMap[src+vertex].nodeList.append(vertex)\n newPath = Path()\n newPath.nodeList = list(self.shortestDistanceMap[src+vertex].nodeList)\n newPath.pathValue = newWeight\n unvisitedQueue.append(newPath)\n print(self.shortestDistanceMap[src+dest].nodeList)\n print(self.shortestDistanceMap[src+dest].pathValue)","def shuffle(self) -> NoReturn:\n for edge_type in self.edge_types:\n for edge_class in range(self.edge_types[edge_type]):\n self.train_edges[edge_type][edge_class] = np.random.permutation(\n self.train_edges[edge_type][edge_class])\n\n self.freebatch_edge_types = {edge_type: list(range(edge_class))\n for edge_type, edge_class in self.edge_types.items()}\n self.batch_num = {edge_type: [0] * edge_class for edge_type, edge_class in\n self.edge_types.items()}\n self.took_all_edges = {edge_type: False for edge_type in self.edge_types}\n self.iter = 0","def __generate_connecticity_increasing_canidates(self,k=3):\n result = set()\n \n if k < 3:\n k = 3\n \n self.__logger.info(\"IMPROOVE_NETWORK: Try to seek {} nodes which are currently bad connected\".format(k))\n candidates = heapq.nlargest(3*k, self.__generate_all_shortest_paths(), key=itemgetter(0))\n\n for _, path in candidates:\n result.add(path[0])\n result.add(path[-1])\n\n self.__logger.info(\"IMPROOVE_NETWORK: Found {} candidates which are currently bad connected\".format(len(result))) \n if len(result) <= k:\n return list(result)\n self.__logger.info(\"IMPROOVE_NETWORK: Sample {} items from the candidates as was requested\".format(k))\n tmp = list(result)\n random.shuffle(tmp)\n return tmp[0:k]","def get_weight_from_minflow(self):\n start_nodes = []\n end_nodes = []\n capacities = []\n unit_costs = []\n A = 0\n s_prime = self.sink() + 1\n t_prime = self.sink() + 2\n x = self.sink() + 3\n # for every edge in the graph, add edge to mincost flow instance with\n # infinite capacity and cost 1\n # also add backwards edge\n for arc in self.arc_info.keys():\n # forward edge\n start_nodes.append(self.arc_info[arc][\"start\"])\n end_nodes.append(self.arc_info[arc][\"destin\"])\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"start\"],\n self.arc_info[arc][\"destin\"]))\n # backward edge\n start_nodes.append(self.arc_info[arc][\"destin\"])\n end_nodes.append(self.arc_info[arc][\"start\"])\n capacities.append(int(self.arc_info[arc][\"weight\"])) # no negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"destin\"],\n self.arc_info[arc][\"start\"]))\n # add (x,s) and (t,x) edges with same cap, cost as above\n in_weight_x = 0\n for in_arc in self.in_arcs_lists[self.sink()]:\n in_weight_x += self.arc_info[in_arc][\"weight\"]\n out_weight_x = 0\n for out_arc in self.out_arcs_lists[self.source()]:\n out_weight_x += self.arc_info[out_arc][\"weight\"]\n # (x,s)\n start_nodes.append(x)\n end_nodes.append(self.source())\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.source()))\n # backward\n start_nodes.append(self.source())\n end_nodes.append(x)\n capacities.append(int(out_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.source(),\n x))\n # (t,x)\n start_nodes.append(self.sink())\n end_nodes.append(x)\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.sink(),\n x))\n # backward\n start_nodes.append(x)\n end_nodes.append(self.sink())\n capacities.append(int(in_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.sink()))\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\n # and cost 0.\n for v in self:\n # process internal verts only, since we assume source and sink have\n # no in and out edges respectively\n if v != self.source() and v != self.sink():\n # compute a-exc(v)\n in_weight = 0\n for in_arc in self.in_arcs_lists[v]:\n in_weight += self.arc_info[in_arc][\"weight\"]\n out_weight = 0\n for out_arc in self.out_arcs_lists[v]:\n out_weight += self.arc_info[out_arc][\"weight\"]\n a_exc = out_weight - in_weight\n if a_exc < 0:\n # add edge (s', v)\n start_nodes.append(s_prime)\n end_nodes.append(v)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n v,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (v, t')\n start_nodes.append(v)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n v,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # process x node\n a_exc = out_weight_x - in_weight_x\n if a_exc < 0:\n # add edge (s', x)\n start_nodes.append(s_prime)\n end_nodes.append(x)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n x,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (x, t')\n start_nodes.append(x)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n x,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # we must send flow of A from s_prime to t_prime\n supplies = [0]*(len(self) + 3)\n supplies[s_prime] = int(A)\n supplies[t_prime] = int(-A)\n # Instantiate a SimpleMinCostFlow solver.\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\n # Add each arc.\n for i in range(len(start_nodes)):\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\n end_nodes[i], capacities[i], unit_costs[i])\n # Add node supplies\n for i in range(0, len(supplies)):\n min_cost_flow.SetNodeSupply(i, supplies[i])\n # Find the minimum cost flow between node s' and t'.\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\n print('Minimum cost:', min_cost_flow.OptimalCost())\n print('')\n print(' Arc Flow / Capacity Cost')\n for i in range(min_cost_flow.NumArcs()):\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\n print('%1s -> %1s %3s / %3s %3s' % (\n min_cost_flow.Tail(i),\n min_cost_flow.Head(i),\n min_cost_flow.Flow(i),\n min_cost_flow.Capacity(i),\n cost))\n # update arcs\n start = min_cost_flow.Tail(i)\n destin = min_cost_flow.Head(i)\n if start != s_prime and \\\n start != t_prime and \\\n start != x and \\\n destin != s_prime and \\\n destin != t_prime and \\\n destin != x:\n # if forward, increase flow. otherwise decrease.\n print(\"Processing edge ({}, {})\".format(start, destin))\n if start < destin:\n sup_flow = min_cost_flow.Flow(i)\n else:\n sup_flow = -min_cost_flow.Flow(i)\n temp_start = start\n start = destin\n destin = temp_start\n print(\"Has become ({}, {}) with sup {}\".format(start,\n destin,\n sup_flow))\n arc = self.get_arc(start, destin)\n if (sup_flow != 0) or (\"lower_bound\" not in \\\n self.arc_info[arc].keys()):\n print(\"We should add this\")\n old_flow = self.arc_info[arc][\"weight\"]\n new_flow = old_flow + sup_flow\n self.arc_info[arc][\"weight\"] = int(new_flow)\n print(\"Edge ({},{}) weight is changed from {} to {}\".format(\n start,\n destin,\n old_flow,\n new_flow))\n else:\n print('There was an issue with the min cost flow input.')\n #self.check_conservation_of_flow() # check that solution is valid","def __generate_random_nodes(self,k=3):\n if k < 3:\n k = 3\n\n k = min(k,len(self.G.nodes()))\n self.__logger.info(\"RANDOM_NODES: try to generate a set of {} nodes sampled with uniform distribution\".format(k))\n \n return random.sample(self.G.nodes(),k)","def find_unique_paths(self, source: str, target: str, number: int = 3) -> List[Tuple[List[str], float]]:\n assert self.graph_handler\n counter = 0\n path_tuple_list = list()\n # # # Initialise iterator over shortest simple paths if it is either not set or source/target do not match\n if not self._use_old_iterator or \\\n self._unique_iterator_memory is None or \\\n self._unique_iterator_memory[0][0][0] != source or \\\n self._unique_iterator_memory[0][0][-1] != target:\n path_iterator = iter(nx.shortest_simple_paths(self.graph_handler.graph, source, target, weight=\"weight\"))\n # # # Find first path and its cost\n old_path = next(path_iterator)\n old_path_cost = nx.path_weight(self.graph_handler.graph, old_path, weight=\"weight\")\n else:\n path_iterator = self._unique_iterator_memory[1]\n old_path = self._unique_iterator_memory[0][0]\n old_path_cost = self._unique_iterator_memory[0][1]\n\n while counter < number:\n same_cost = True\n tmp_path_list: List[List[str]] = list()\n # # # Collect all paths with same cost\n # TODO: Parameter for max tmp paths\n n_max_collected_paths = 10\n while same_cost and len(tmp_path_list) < n_max_collected_paths:\n # # # Append old path to tmp_path list\n tmp_path_list.append(old_path)\n # # # Get next path and its cost\n new_path = next(path_iterator, None)\n # # # Break loop if no path is returned\n if new_path is None:\n break\n new_path_cost = nx.path_weight(self.graph_handler.graph, new_path, weight=\"weight\")\n # # # Check if new cost different to old cost\n if abs(old_path_cost - new_path_cost) > 1e-12:\n same_cost = False\n # # # Overwrite old path with new path\n old_path = new_path\n\n # # # Append path with most nodes to tuple list and its cost\n path_tuple_list.append((max(tmp_path_list, key=lambda x: len(x)), # pylint: disable=unnecessary-lambda\n old_path_cost))\n # # # Break counter loop if no more paths to target are found\n if new_path is None:\n break\n old_path_cost = new_path_cost\n counter += 1\n # # # Store iterator and path info (list of nodes and length)\n if new_path is not None:\n self._unique_iterator_memory = ((new_path, new_path_cost), path_iterator)\n return path_tuple_list","def __dynamicThroughput( self, sourceSEs, destSEs ):\n res = self.__getTimeToStart()\n if not res['OK']:\n gLogger.error( res['Message'] )\n return {}\n channelInfo = res['Value']\n\n timeToSite = {} # Maintains time to site including previous hops\n siteAncestor = {} # Maintains the ancestor channel for a site\n tree = {} # Maintains replication tree\n while len( destSEs ) > 0:\n minTotalTimeToStart = float( \"inf\" )\n candidateChannels = []\n sourceActiveSEs = self.__getActiveSEs( sourceSEs )\n for destSE in destSEs:\n destSites = self.__getChannelSitesForSE( destSE )\n localTransfer = False\n for destSite in destSites:\n if localTransfer: break\n for sourceSE in sourceActiveSEs:\n if localTransfer: break\n sourceSites = self.__getChannelSitesForSE( sourceSE )\n for sourceSite in sourceSites:\n if localTransfer: break\n channelName = '%s-%s' % ( sourceSite, destSite )\n if channelInfo.has_key( channelName ):\n channelID = channelInfo[channelName]['ChannelID']\n if tree.has_key( channelID ):\n continue\n channelTimeToStart = channelInfo[channelName]['TimeToStart']\n if timeToSite.has_key( sourceSE ):\n totalTimeToStart = timeToSite[sourceSE] + channelTimeToStart + self.sigma\n else:\n totalTimeToStart = channelTimeToStart\n #print '%s-%s %s %s' % (sourceSE,destSE,channelTimeToStart,totalTimeToStart)\n localTransfer = ( sourceSite == destSite )\n if localTransfer or totalTimeToStart < minTotalTimeToStart:\n minTotalTimeToStart = totalTimeToStart\n selectedPathTimeToStart = totalTimeToStart\n candidateChannels = [( sourceSE, destSE, channelID )]\n elif totalTimeToStart == minTotalTimeToStart:\n candidateChannels.append( ( sourceSE, destSE, channelID ) )\n\n #minTotalTimeToStart = totalTimeToStart\n #selectedPathTimeToStart = totalTimeToStart\n #selectedSourceSE = sourceSE\n #selectedDestSE = destSE\n #selectedChannelID = channelID\n else:\n errStr = 'StrategyHandler.__dynamicThroughput: Channel not defined'\n gLogger.warn( errStr, channelName )\n\n #print 'Selected %s \\n' % selectedPathTimeToStart\n\n random.shuffle( candidateChannels )\n selectedSourceSE, selectedDestSE, selectedChannelID = candidateChannels[0]\n timeToSite[selectedDestSE] = selectedPathTimeToStart\n siteAncestor[selectedDestSE] = selectedChannelID\n\n if siteAncestor.has_key( selectedSourceSE ):\n waitingChannel = siteAncestor[selectedSourceSE]\n else:\n waitingChannel = False\n tree[selectedChannelID] = {}\n tree[selectedChannelID]['Ancestor'] = waitingChannel\n tree[selectedChannelID]['SourceSE'] = selectedSourceSE\n tree[selectedChannelID]['DestSE'] = selectedDestSE\n tree[selectedChannelID]['Strategy'] = 'DynamicThroughput'\n sourceSEs.append( selectedDestSE )\n destSEs.remove( selectedDestSE )\n return tree","def run_destination_reduction(self):\n s = self.sources\n t = self.destinations\n\n # get the union set of source edges\n s_edges = [self.out_edges(x) for x in s]\n s_edges_idx = [set(self.get_edges_indices(src)) for src in s_edges]\n S = set.union(*s_edges_idx)\n\n # now starting from the sources\n T_curr = [set(self.in_edges(x)) for x in t]\n T_curr_idx = [set(self.get_edges_indices(x)) for x in T_curr]\n T_union = set.union(*[set(x) for x in T_curr])\n T_union_idx = set.union(*T_curr_idx)\n self.dst_evolution_rec = [T_curr_idx]\n\n while not T_union_idx.issubset(S):\n # get the edges out of the max-ordered node\n tail_nodes = set([x[0] for x in T_union])\n tail_nodes = tail_nodes - set(s)\n v = max(tail_nodes, key=lambda p: self.node[p]['index'])\n\n E = set([edge for edge in T_union if edge[0] == v])\n E_curr = [x.intersection(E) for x in T_curr]\n\n T_next = []\n Uv = self.in_edges(v)\n for (Ex, Tx) in zip(E_curr, T_curr):\n if Ex:\n T_next.append((Tx - Ex).union(Uv))\n else:\n T_next.append(Tx)\n\n T_curr = T_next\n T_curr_idx = [set(self.get_edges_indices(x)) for x in T_curr]\n self.dst_evolution_rec.append(T_curr_idx)\n\n T_union = set.union(*[set(x) for x in T_curr])\n T_union_idx = set.union(*T_curr_idx)","def configuration_model(g, kmin, kmax, size, c, offset):\n # Makes sure that networks have an even number of half-edges, since\n # the number of half-edges prepared for linking can be uneven.\n its = inverse_transform_sampling(g, kmin, kmax, size, offset)\n sum_its = sum(its)\n while sum_its % 2 != c % 2:\n its = inverse_transform_sampling(g, kmin, kmax, size, offset)\n sum_its = sum(its)\n\n # Brings the dist. seq. into the half-edge form,\n # e.g. [1,2,3] -> [0,1,1,2,2,2]\n seq = []\n k = 0\n for i in range(size):\n for j in range(k, k + its[i]):\n seq += [i]\n k += 1\n\n # Edges that link to other modules\n c_node = np.random.choice(seq, size=c, replace=False)\n for i in range(c):\n seq.remove(c_node[i])\n \n # Connects the half-edges randomly among each other\n np.random.shuffle(seq)\n links = np.sort(np.reshape(seq, (int(len(seq)/2), 2)))\n links = links.tolist()\n \n # Separates the unique and the multi/self links.\n # The list links is left with multi and self links.\n links_unique = []\n k = 0\n while k < len(links):\n if links[k][0] != links[k][1] and links[k] not in links_unique:\n links_unique.append(links.pop(k))\n else:\n k += 1\n \n # Rewires the multi/self links\n for multi in links:\n r1 = random.randint(0, len(links_unique)-1)\n r2 = random.randint(0, 1)\n r3 = random.randint(0, 1)\n links_unique[r1][r2], multi[r3] = multi[r3], links_unique[r1][r2]\n \n network = gt.Graph(directed=False)\n network.add_edge_list(links_unique)\n network.add_edge_list(links)\n\n gt.stats.remove_parallel_edges(network)\n gt.stats.remove_self_loops(network)\n \n return network, c_node","def gen_task_sets_fairgen(nsets):\n start = time()\n eval_task_sets = []\n for util in utils:\n task_sets = []\n for i in range(nsets):\n ts = synth.mc_fairgen(set_id=i, u_lo=util, implicit_deadlines=True)\n synth.synth_c_pmf(ts)\n synth.set_fixed_priorities(ts)\n task_sets.append(ts)\n eval_task_sets.append(task_sets)\n stop = time()\n print('Task Set Generation MC-Fairgen: %.3fs' % (stop - start))\n pickle.dump(eval_task_sets, open(task_sets_path + 'task_sets_fairgen', 'wb'))","def optimal_route(graph,homes,source):\n number_of_homes = len(homes)\n all_pairs_distances = dict(nx.shortest_path_length(graph, weight = 'weight'))\n all_pairs_shortest_paths = dict(nx.shortest_path(graph, weight = 'weight'))\n homes_subgraph = tsp_routines.complete_shortest_path_subgraph_efficient(graph,homes,all_pairs_distances)\n num_clusters_to_clustering = clustering_routines.all_k_clusters(homes_subgraph,number_of_homes)\n \n cluster_list = range(1,number_of_homes+1)\n optimal_cost = np.Inf\n optimal_dropoffs = dict()\n optimal_route = []\n optimal_num_clusters = 0\n\n\n for num_clusters in cluster_list:\n home_clusters = num_clusters_to_clustering[num_clusters]\n cost, dropoffs, route = solver(graph,homes,source,home_clusters,all_pairs_distances,all_pairs_shortest_paths)\n if cost < optimal_cost:\n optimal_cost = cost\n optimal_route = route \n optimal_dropoffs = dropoffs\n optimal_num_clusters = num_clusters\n\n return optimal_cost, optimal_dropoffs, optimal_route, optimal_num_clusters","def simulate_graph(seed, cluster_sizes, del_factor, ins_factor):\n rand.seed(seed)\n cluster_boundaries = np.cumsum(cluster_sizes)\n print(\"#seed:\", seed)\n print(\"#deletion factor:\", del_factor)\n print(\"#insertion factor:\", ins_factor)\n optimal_costs = np.array([0])\n for c in range(0, len(cluster_sizes)-1):\n n_c = cluster_sizes[c+1]\n offset_c = cluster_boundaries[c]\n edges_c = generate_edges(n_c, offset_c)\n disturb_cluster(n_c, offset_c, edges_c, del_factor, optimal_costs)\n additional_edges(cluster_boundaries, ins_factor, optimal_costs)\n print(\"#optimal costs:\", optimal_costs)","def _measure(d, sources, target, niter=25, bound=None):\n uniques = {}\n for source in sources:\n others = list(sources)\n others.remove(source)\n others = list(flatten(others))\n uniques[source] = one_way_skar(d, source, target, others)\n return uniques","def update_flow(self):\n N = len(self.vertices)\n _vertices = self.vertices+['_source', '_sink']\n s, t = _vertices.index('_source'), _vertices.index('_sink')\n cost, capacity = dok_matrix((N+2, N+2)), dok_matrix((N+2, N+2))\n\n cost[:N, :N] = self.cost\n capacity[:N, :N] = self.upper_bound-self.lower_bound\n # _source to main vertices\n l_in = self.lower_bound.toarray().sum(axis=0)\n us, = l_in.nonzero()\n for u in us:\n capacity[s, u] = l_in[u]\n # main vertices to _sink\n l_out = self.lower_bound.toarray().sum(axis=1)\n us, = l_out.nonzero()\n for u in us:\n capacity[u, t] = l_out[u]\n # sink to source\n infinite_flow = self.upper_bound.toarray().sum()\n capacity[_vertices.index('sink'), _vertices.index('source')] = infinite_flow\n\n # get a feasible flow on original graph by finding the max flow on\n # auxiliary graph\n aux_fg = FlowGraph(_vertices, cost, capacity, True)\n aux_fg.FordFulkerson()\n assert aux_fg.residual[s].toarray().sum()==0, 'feasible flow within bounds not found'\n\n self.residual = aux_fg.residual[:N, :N]\n s, t = self.vertices.index('source'), self.vertices.index('sink')\n self.residual[s, t] = 0\n self.residual[t, s] = 0\n\n self.FordFulkerson()","def choose_paths_without_simulation(FT, output_dir, iteration, pathset_paths_df, pathset_links_df, veh_trips_df):\n simulation_iteration = 0\n ######################################################################################################\n FastTripsLogger.info(\" Step 1. Find out board/alight times for all pathset links from vehicle times\")\n\n # could do this just to chosen path links but let's do this to the whole pathset\n pathset_links_df = Assignment.find_passenger_vehicle_times(pathset_links_df, veh_trips_df)\n\n # instead of flag_missed_transfers(), set these to pathfinding results\n pathset_links_df[Assignment.SIM_COL_PAX_ALIGHT_DELAY_MIN] = 0\n pathset_links_df[Assignment.SIM_COL_PAX_A_TIME ] = pathset_links_df[Passenger.PF_COL_PAX_A_TIME]\n pathset_links_df[Assignment.SIM_COL_PAX_B_TIME ] = pathset_links_df[Passenger.PF_COL_PAX_B_TIME]\n pathset_links_df[Assignment.SIM_COL_PAX_LINK_TIME ] = pathset_links_df[Passenger.PF_COL_LINK_TIME]\n pathset_links_df[Assignment.SIM_COL_PAX_WAIT_TIME ] = pathset_links_df[Passenger.PF_COL_WAIT_TIME]\n pathset_links_df[Assignment.SIM_COL_PAX_MISSED_XFER ] = 0\n\n ######################################################################################################\n FastTripsLogger.info(\" Step 2. Calculate costs and probabilities for all pathset paths\")\n (pathset_paths_df, pathset_links_df) = PathSet.calculate_cost(\n iteration, simulation_iteration, Assignment.STOCH_DISPERSION,\n pathset_paths_df, pathset_links_df, FT.passengers.trip_list_df,\n FT.transfers.transfers_df, FT.tazs.walk_df, FT.tazs.drive_df, veh_trips_df, FT.stops)\n\n ######################################################################################################\n FastTripsLogger.info(\" Step 3. Choose a path for each passenger from their pathset\")\n\n # Choose path for each passenger -- pathset_paths_df and pathset_links_df will now have\n # SIM_COL_PAX_CHOSEN >=0 for chosen paths/path links\n (num_passengers_arrived, num_chosen, pathset_paths_df, pathset_links_df) = Passenger.choose_paths(\n True, # choose for everyone\n iteration, simulation_iteration,\n pathset_paths_df, pathset_links_df)\n\n # Write the pathsets\n Passenger.write_paths(output_dir, iteration, simulation_iteration, pathset_paths_df, False, Assignment.OUTPUT_PATHSET_PER_SIM_ITER)\n Passenger.write_paths(output_dir, iteration, simulation_iteration, pathset_links_df, True, Assignment.OUTPUT_PATHSET_PER_SIM_ITER)\n\n # write the final chosen paths for this iteration\n chosen_links_df = Passenger.get_chosen_links(pathset_links_df)\n chosen_links_df[\"iteration\"] = iteration\n Util.write_dataframe(chosen_links_df, \"chosen_links_df\", os.path.join(output_dir, \"chosenpaths_links.csv\"), append=(iteration>1))\n chosen_links_df.drop([\"iteration\"], axis=1, inplace=True)\n\n chosen_paths_df = Passenger.get_chosen_links(pathset_paths_df)\n chosen_paths_df[\"iteration\"] = iteration\n Util.write_dataframe(chosen_paths_df, \"chosen_paths_df\", os.path.join(output_dir, \"chosenpaths_paths.csv\"), append=(iteration>1))\n chosen_paths_df.drop([\"iteration\"], axis=1, inplace=True)\n\n return (num_passengers_arrived, pathset_paths_df, pathset_links_df)","def step(nodes, outputs, edges):\n flowed = []\n for node_name in nodes.copy():\n if node_name in flowed:\n continue\n if len(nodes[node_name]) == 2:\n if node_name in flowed:\n continue\n node = [int(value) for value in nodes[node_name]]\n low_value, high_value = min(node), max(node)\n low_flow, high_flow = edges[node_name] \n low_dictionary, low_node_name = low_flow\n high_dictionary, high_node_name = high_flow\n low_node = low_dictionary.get(low_node_name, tuple())\n high_node = high_dictionary.get(high_node_name, tuple())\n low_dictionary[low_node_name] = low_node + (str(low_value),)\n high_dictionary[high_node_name] = high_node + (str(high_value),)\n nodes[node_name] = tuple()\n if low_dictionary is nodes:\n flowed.append(low_node_name)\n if high_dictionary is nodes:\n flowed.append(high_node_name)\n return nodes, outputs, edges","def get_random_depth_sample(n=8, depths=list(range(2,26,2)), num_samples=100):\n\n def get_states(start):\n frontier = [start]\n frontier_set = {start}\n explored = set()\n\n states = [False for _ in range(len(depths))]\n while not all(states):\n node = frontier.pop(0)\n frontier_set.remove(node)\n explored.add(node)\n\n children = node.get_children()\n\n # It's necessary to shuffle children to get a truly random sample; otherwise, the first child (always\n # produced from the parent by the same action) produced at a certain depth will always be selected,\n # and children produced by other actions will never be selected\n shuffle(children)\n\n for child in children:\n if child not in frontier_set and child not in explored:\n frontier_set.add(child)\n frontier.append(child)\n child.path_cost = node.path_cost+1\n index = depths.index(child.path_cost) if child.path_cost in depths else None\n if index is not None and not states[index]:\n states[index] = {'start': start.sequence, 'end': child.sequence}\n\n return states\n\n depth_sample = [[] for depth in range(len(depths))]\n\n for _ in range(num_samples):\n start = list(range(1,n+2))\n shuffle(start)\n start = PuzzleState(start, path_cost=0)\n\n states = get_states(start)\n print('\\rSet ' + str(_+1) + ' of ' + str(num_samples) + ' complete', end='', flush=True)\n list(map(list.append, depth_sample, states))\n\n return depth_sample","def _measure(d, sources, target, niter=25, bound=None):\n uniques = {}\n for source in sources:\n others = list(sources)\n others.remove(source)\n others = list(flatten(others))\n uniques[source] = one_way_skar(d, target, source, others)\n return uniques","def sinks(self):\n s = [node for node in self.nodes() if node.isSink()]\n s.sort(lambda x,y: cmp(x._id, y._id))\n return s","def splitSources(sources: Iterable[FileId], chunkSize: int) -> List[List[FileId]]:\n if chunkSize <= 0:\n raise ValueError(f\"chunkSize must be positive ({chunkSize})\")\n\n sentinel = FileId(visit=math.nan, arm=None, spectrograph=None)\n sources = [sentinel] + sorted(sources, key=lambda x: x.visit) + [sentinel]\n\n # Split sources into sequences, each contiguous in terms of visits.\n contiguousSeqs = []\n for iscontiguous, group in itertools.groupby(\n zip(sources[:-1], sources[1:]),\n key=lambda pair: pair[1].visit - pair[0].visit == 1\n ):\n group = list(group)\n if iscontiguous:\n contiguousSeqs.append([pair[0] for pair in group] + [group[-1][-1]])\n else:\n contiguousSeqs.extend([pair[-1]] for pair in group[:-1])\n\n # Further split the contiguous sequences into small chunks\n chunks = []\n for seq in contiguousSeqs:\n n = len(seq)\n numChunks = (n + chunkSize - 1) // chunkSize\n quotient = n // numChunks\n remainder = n % numChunks\n for i in range(numChunks):\n if remainder > 0:\n remainder -= 1\n numToPop = quotient + 1\n else:\n numToPop = quotient\n chunks.append(seq[:numToPop])\n seq = seq[numToPop:]\n assert(len(seq) == 0)\n\n return chunks","def shortest_route(self, src, dest):\n\n # Dijkstra with unusual start condition to prevent src -> src == 0 distance\n x_in = set()\n a = defaultdict(lambda: float('inf'))\n v = self.V.copy()\n\n for node, cost in self.G[src].items():\n a[node] = cost\n x_in.add(node)\n v.remove(node)\n\n while x_in != self.V:\n mn = float('inf')\n new = None\n for x in x_in:\n for node, cost in self.G[x].items():\n if node in v:\n if (a[x] + cost) < mn: # optimize large/dense G with pri. q\n mn = a[x] + cost\n new = (x, node, cost)\n if new is None:\n break\n x, node, cost = new\n x_in.add(node)\n v.remove(node)\n a[node] = a[x] + cost\n return a[dest]","def find_all_cycles(s,graph):\n\n grph = u.edge_to_list_dict(graph)\n node_cnt = len(grph)\n k = z.Int(\"k\")\n syms = [z.Int('node%s'%i) for i in range(node_cnt)]\n\n # s.add(syms[0] == 0) # start node is a 0\n s.add(k < node_cnt)\n s.add(k > 1)\n\n o = z.Optimize()\n\n # for source, sinks in sgraph.s_adj_list():\n for i in range(node_cnt):\n s.add(syms[i] >= 0)\n s.add(syms[i] <= k)\n s.add(z.Or([syms[j] == ((syms[i] + 1) % k) for j in grph[i]]) == (syms[i] == 0))\n\n\n r = []\n m = []\n\n # o.minimize(z.Sum([syms[i] for i in range(node_cnt)]))\n s.add(z.Product([syms[i] for i in range(node_cnt)]) == 0)\n done = False\n while not done:\n if s.check() == z.sat:\n m = s.model()\n r.append(m)\n s.add(k != m[k])\n else:\n done = True\n\n return r","def sample_paths(S0, N, u, d, q, M):\n value = S0 * np.ones((M, 1)) # M sample paths at once\n paths = np.zeros((M, N + 1))\n paths[:, 0] = value[:, 0]\n for i in np.arange(1, N + 1, 1): # time steps\n random_values = bernoulli.rvs(size=(M, 1), p=q)\n up_moves = random_values * u\n down_moves = -1 * (random_values - 1) * d\n value = np.multiply(value, up_moves + down_moves)\n paths[:, i] = value[:, 0]\n return paths","def choose_k_away(k, node, precomputed=True):\n if precomputed:\n sps = np.load('./short_paths/' + str(node) + '.npy')\n else:\n sps = shortest_path(node)\n nodes = []\n for index, x in enumerate(sps):\n if x == k and index in poss_targets:\n nodes.append(index)\n return nodes","def naiveGlobalRouting(self):\n for e_list in self.s2e.values():\n for e in e_list:\n slot_path = []\n src_slot = self.v2s[e.src]\n dst_slot = self.v2s[e.dst]\n slot_path.append(src_slot)\n\n curr = src_slot\n len_x = src_slot.getLenX()\n len_y = src_slot.getLenY()\n\n # first go in X direction\n x_diff = curr.getPositionX() - dst_slot.getPositionX()\n if x_diff:\n dir = 'LEFT' if x_diff > 0 else 'RIGHT'\n for i in range(int(abs(x_diff/len_x))):\n curr = self.slot_manager.createSlotForRouting(curr.getNeighborSlotName(dir))\n slot_path.append(curr)\n\n y_diff = curr.getPositionY() - dst_slot.getPositionY()\n if y_diff:\n dir = 'DOWN' if y_diff > 0 else 'UP'\n for i in range(int(abs(y_diff/len_y))):\n curr = self.slot_manager.createSlotForRouting(curr.getNeighborSlotName(dir))\n slot_path.append(curr)\n \n assert curr == dst_slot\n \n slot_path = slot_path[1:-1] # exclude the src and the dst\n logging.info(f'{e.name}: {self.v2s[e.src].getName()} -> {self.v2s[e.dst].getName()} : ' + ' '.join(s.getName() for s in slot_path))\n self.e_name2path[e.name] = slot_path","def djikstra(nodes,links,source,dest):\n route = []\n vertexes = []\n for v in nodes:\n v.set_dist(float(\"inf\"))\n v.set_prev(None)\n heappush(vertexes, v)\n source.set_dist(0)\n heapify(vertexes)\n while vertexes:\n unsorted = False\n u = heappop(vertexes)\n if u == dest:\n break #because we found the destination no need to look further\n for v in u.get_links():\n if v.get_enabled():\n alt = u.get_dist() + 1\n target = v.get_target()\n if alt < target.get_dist():\n target.set_dist(alt)\n target.set_prev(u)\n unsorted = True #just a variable that help check if changes were made to the objects inside the heap\n if unsorted: #because i updated the variables but the heap wasn't maintained, i just heapify it again\n heapify(vertexes) \n #this is the part that saves the distance and route \n if dest.get_dist() == float(\"inf\"): #if there is no route then we just return None\n return None\n u = dest\n while u.get_prev() != None:\n v = u.get_prev()\n route.insert(0, v.get_specific_link(u)) \n u = v\n return route","def connecting_graph(self, solution_graph, weight='cost', ignore_sources=False):\n debut = time.time()\n self.logger.info('start connecting graph')\n\n # we need an undirected graph\n undirected_solution_graph = solution_graph.to_undirected()\n\n if self.old_network_graph is not None and self.modify_old_network:\n undirected_solution_graph = nx.compose(nx.MultiGraph(self.old_network_graph), undirected_solution_graph)\n\n # if already connected\n if nx.is_connected(undirected_solution_graph) == True:\n self.logger.info(\"the solution graph is already connected\")\n return []\n\n # Computing the minimum sources in each component and all junction nodes in the solution graph\n nodetype = nx.get_node_attributes(undirected_solution_graph, config.NODE_TYPE_KEY)\n list_sources = [node for node in nodetype if nodetype[node] == config.SUPPLY_NODE_TYPE]\n\n # 1. Search of all connected subgraphs\n if not ignore_sources:\n reduced_list_sources = []\n while len(list_sources) > 0:\n source, is_isolated = list_sources.pop(0), True\n for i in range(len(list_sources)):\n is_isolated = is_isolated and not (nx.has_path(undirected_solution_graph, source, list_sources[i]))\n if is_isolated:\n reduced_list_sources.append(source)\n else:\n reduced_list_sources = [list(n)[0] for n in nx.connected_components(undirected_solution_graph)]\n\n # 2. Creation of all convex hulls for each source in reduced_list_sources\n hulls = {}\n for source in reduced_list_sources:\n coord_compo = {}\n nodes_connecting_source = nx.node_connected_component(undirected_solution_graph, source)\n for node in nodes_connecting_source:\n xy = tuple(self.optimization_graph.get_node_coordinates(node))\n coord_compo[xy] = node\n if len(coord_compo) > 2:\n convexhull = ConvexHull(list(coord_compo.keys())).points\n else:\n convexhull = list(coord_compo.keys())\n hulls[source] = [coord_compo[tuple(coord)] for coord in convexhull]\n\n # 3. Create list of possible list_edges_to_add\n list_edges_to_add = {} # list of {(S1, S2):(length_of_SP, edges_to_add)}\n\n for S1, S2 in combinations(reduced_list_sources, 2):\n\n # change weight of edges\n for i in range(len(hulls[S1])-1):\n u,v = hulls[S1][i], hulls[S1][i+1]\n self.optimization_graph.add_edge(u,v,key=-1,weight=0)\n self.optimization_graph.add_edge(hulls[S1][-1],hulls[S1][0],key=-1,weight=0)\n for i in range(len(hulls[S2])-1):\n u,v = hulls[S2][i], hulls[S2][i+1]\n self.optimization_graph.add_edge(u,v,key=-1,weight=0)\n self.optimization_graph.add_edge(hulls[S2][-1],hulls[S2][0],key=-1,weight=0)\n\n # find the shortest path\n source, target = hulls[S1][0], hulls[S2][0] # it's a choice to take 0, but no matter\n try:\n length, path = nx.single_source_dijkstra(self.optimization_graph, source, target=target, weight=weight)\n except nx.NetworkXNoPath:\n self.logger.info(\"Source \" + str(S1) + \" and source \" + str(S2) + \" can't be connected\")\n return []\n list_weights = nx.get_edge_attributes(self.optimization_graph, weight)\n\n # edges to add to connect S1 and S2\n edges_to_add = []\n for i in range(len(path) - 1):\n u, v = path[i], path[i + 1]\n # if the edge between (u,v) is not artificial, we add it\n if list_weights.get((u, v, -1), None) != 0 and list_weights.get((u, v, 0), None) is not None:\n edges_to_add.append((u, v, 0))\n if list_weights.get((v, u, -1), None) != 0 and list_weights.get((v, u, 0), None) is not None:\n edges_to_add.append((v, u, 0))\n list_edges_to_add[(S1, S2)] = (length, edges_to_add)\n\n # change weight of edges\n for i in range(len(hulls[S1])-1):\n u,v = hulls[S1][i], hulls[S1][i+1]\n self.optimization_graph.remove_edge(u,v,key=-1)\n self.optimization_graph.remove_edge(hulls[S1][-1],hulls[S1][0],key=-1)\n for i in range(len(hulls[S2])-1):\n u,v = hulls[S2][i], hulls[S2][i+1]\n self.optimization_graph.remove_edge(u,v,key=-1)\n self.optimization_graph.remove_edge(hulls[S2][-1],hulls[S2][0],key=-1)\n\n\n # 4. choice of best edges to add (Kruskal)\n G = nx.Graph()\n for (S1, S2) in list_edges_to_add:\n (length, _) = list_edges_to_add[(S1, S2)]\n if not G.has_node(S1):\n G.add_node(S1)\n if not G.has_node(S2):\n G.add_node(S2)\n G.add_edge(S1, S2, weight=length)\n\n reduced_list_edges_to_add = set()\n T = nx.minimum_spanning_tree(G)\n for u, v in T.edges:\n if (u, v) in list_edges_to_add:\n reduced_list_edges_to_add = reduced_list_edges_to_add.union(set(list_edges_to_add[(u, v)][1]))\n if (v, u) in list_edges_to_add:\n reduced_list_edges_to_add = reduced_list_edges_to_add.union(set(list_edges_to_add[(v, u)][1]))\n\n self.logger.info('end connecting graph in ' + str(time.time() - debut) + ' s')\n return list(reduced_list_edges_to_add)","def randnet(G):\n\t\n\t#initializationo of the lists\n\telst = G.get_edgelist()\n\tclst = G.es['color'][:]\n\tcdic = {}\n\tfor i,c in enumerate(clst):\n\t\tcdic[c]=i\n\tlst1 = [[]]*len(key)\n\tfor i,e in enumerate(elst):\n\t\tlst1[cdic[clst[i]]].append([e[0],e[1]])\n\t\t\n\t#randomization procedure\n\tfor i in range(random.randrange(100,200)):\n\t\tcid = cdic[random.choice(clst)] #random choice weighted by the frequency of each color\n\t\te1id = random.randrange(0,len(lst1[cid])) #random choice of edge with that color\n\t\te2id = random.randrange(0,len(lst1[cid]))\n\t\textop = random.randrange(0,2)#random choice of top/bottom\n\t\tttemp = lst1[cid][e1id][extop]\n\t\tlst1[cid][e1id][extop] = lst1[cid][e2id][extop]\n\t\tlst1[cid][e2id][extop] = ttemp\n\t\n\tcoutlst = []\n\teoutlst\t= []\n\tfor i in range(len(lst1)):\n\t\tc = clst[i]\n\t\tfor e in lst1[i]:\n\t\t\tcoutlst.append(c)\n\t\t\teoutlst.append((e[0],e[1]))\n\n\treturn [eoutlst,coutlst]","def _ism_get_mirror_sources(source, receiver, walls, order_threshold, mirrors_threshold):\n logger.info(\"_ism_get_mirror_sources: Determining mirror sources.\")\n model = ism.Model(walls=walls, source=source, receiver=receiver, max_order=order_threshold)\n mirrors = model.determine(strongest=mirrors_threshold)\n yield from mirrors","def gen_task_sets_simplegen(nsets):\n start = time()\n eval_task_sets = []\n for util in utils:\n task_sets = []\n for i in range(nsets):\n ts = synth.simplegen(i, util, implicit_deadlines=True)\n synth.synth_c_pmf(ts, distribution_cls=lib.ExpExceedDist)\n synth.set_fixed_priorities(ts)\n task_sets.append(ts)\n eval_task_sets.append(task_sets)\n stop = time()\n print('Task Set Generation SimpleGen: %.3fs' % (stop - start))\n pickle.dump(eval_task_sets, open(task_sets_path + 'task_sets_simplegen', 'wb'))","def _measure(d, sources, target, niter=25, bound=None):\n uniques = {}\n for source in sources:\n others = list(sources)\n others.remove(source)\n others = list(flatten(others))\n uniques[source] = two_way_skar(d, [source, target], others)\n return uniques","def _graph_fn_sample_stochastic(distribution):\n return distribution.sample()","def dfs_edges_generator(graph, source, reverse=...):\n ...","def get_all_sghop_info (nffg, return_paths=False):\n sg_map = {}\n for i in nffg.infras:\n for p in i.ports:\n for fr in p.flowrules:\n # if fr.external:\n # continue\n if fr.id not in sg_map:\n # The path is unordered!!\n path_of_shop = []\n flowclass = NFFGToolBox._extract_flowclass(fr.match.split(\";\"))\n sg_map[fr.id] = [None, None, flowclass, fr.bandwidth, fr.delay]\n # We have to find the BEGINNING of this flowrule sequence.\n inbound_link = NFFGToolBox._find_infra_link(nffg, p, outbound=False,\n accept_dyn=True)\n while inbound_link.type != 'DYNAMIC':\n path_of_shop.append(inbound_link)\n if inbound_link.src.node.type == 'SAP':\n break\n # The link is STATIC, and its src is not SAP so it is an Infra.\n prev_fr, prev_p = \\\n NFFGToolBox._get_flowrule_and_its_starting_port(\n inbound_link.src.node, fr.id)\n NFFGToolBox._check_flow_consistencity(sg_map, prev_fr)\n inbound_link = NFFGToolBox._find_infra_link(nffg, prev_p,\n outbound=False,\n accept_dyn=True)\n # 'inbound_link' is DYNAMIC here or it is STATIC and starts from\n # a SAP,\n # so the sequence starts here\n sg_map[fr.id][0] = inbound_link.src\n\n # We have to find the ENDING of this flowrule sequence.\n output_port = NFFGToolBox._get_output_port_of_flowrule(i, fr)\n if output_port is None:\n continue\n outbound_link = NFFGToolBox._find_infra_link(nffg, output_port,\n outbound=True,\n accept_dyn=True)\n while outbound_link.type != 'DYNAMIC':\n path_of_shop.append(outbound_link)\n if outbound_link.dst.node.type == 'SAP':\n break\n # The link is STATIC and its dst is not a SAP so it is an Infra.\n next_fr, _ = NFFGToolBox._get_flowrule_and_its_starting_port(\n outbound_link.dst.node, fr.id)\n # '_' is 'outbound_link.dst'\n next_output_port = NFFGToolBox._get_output_port_of_flowrule(\n outbound_link.dst.node, next_fr)\n NFFGToolBox._check_flow_consistencity(sg_map, next_fr)\n outbound_link = NFFGToolBox._find_infra_link(nffg,\n next_output_port,\n outbound=True,\n accept_dyn=True)\n # the 'outbound_link' is DYNAMIC here or finishes in a SAP, so the\n # flowrule sequence finished here.\n sg_map[fr.id][1] = outbound_link.dst\n\n if return_paths:\n sg_map[fr.id].append(path_of_shop)\n\n return sg_map","def randomNetwork(self, numVertices, numEdges, capacityRange):\r\n for _ in range(numEdges):\r\n fromVertex, toVertex = None, None\r\n while fromVertex == toVertex or (fromVertex, toVertex) in self.capacity:\r\n fromVertex = randint(1, numVertices)\r\n toVertex = randint(1, numVertices)\r\n capacity = randint(1, capacityRange) \r\n self.addEdge(fromVertex, toVertex, capacity)","def sample_paths(S0, N, u, d, q, M):\n value = S0*np.ones((M,1)) # M sample paths at once\n paths = np.zeros((M, N+1))\n paths[:,0] = value[:,0]\n for i in np.arange(1, N+1,1): # time steps\n random_values = bernoulli.rvs(size=(M,1),p=q)\n up_moves = random_values*u\n down_moves = -1*(random_values-1)*d \n value = np.multiply(value,up_moves+down_moves)\n paths[:,i] = value[:,0]\n return paths","def _compute_flows(paths):\n assert isinstance(paths, list)\n\n # allocate memory\n flows = np.zeros([len(paths), FLAGS.target_height, FLAGS.target_width, 2],\n dtype=np.float32)\n\n # load all images\n pbar = ProgressBar(max_value=len(paths))\n for i in range(len(paths)-1):\n im1 = skimage.io.imread(paths[i])\n im2 = skimage.io.imread(paths[i+1])\n\n im1 = cv2.cvtColor(im1, cv2.COLOR_RGB2GRAY)\n im2 = cv2.cvtColor(im2, cv2.COLOR_RGB2GRAY)\n im1 = skimage.transform.resize(\n im1, [FLAGS.target_height, FLAGS.target_width], preserve_range=True,\n mode='constant', anti_aliasing=True)\n im2 = skimage.transform.resize(\n im2, [FLAGS.target_height, FLAGS.target_width], preserve_range=True,\n mode='constant', anti_aliasing=True)\n flow = cv2.calcOpticalFlowFarneback(\n im1, im2, flow=None, pyr_scale=0.5, levels=3, winsize=15,\n iterations=3, poly_n=5, poly_sigma=1.2, flags=0)\n\n # store images\n flows[i] = flow\n pbar.update(i)\n\n # Replicate the flow for last frame\n flows[-1] = flow\n return flows","def sources(self):\n return [x for x in self if self.in_degree(x)==0]","def get_flows(self, num_flows_per_entry):\n flows = []\n for tenant in self._tenants:\n for contract in tenant.get_children(only_class=Contract):\n providing_epgs = contract.get_all_providing_epgs()\n consuming_epgs = contract.get_all_consuming_epgs()\n for providing_epg in providing_epgs:\n vlan_ifs = providing_epg.get_all_attached(L2Interface)\n if len(vlan_ifs):\n providing_vlan = vlan_ifs[0].encap_id\n phys_ifs = vlan_ifs[0].get_all_attached(Interface)\n if len(phys_ifs):\n providing_phys_if = phys_ifs[0].name\n for consuming_epg in consuming_epgs:\n vlan_ifs = consuming_epg.get_all_attached(L2Interface)\n if len(vlan_ifs):\n consuming_vlan = vlan_ifs[0].encap_id\n phys_ifs = vlan_ifs[0].get_all_attached(Interface)\n if len(phys_ifs):\n consuming_phys_if = phys_ifs[0].name\n if providing_vlan == consuming_vlan and providing_phys_if == consuming_phys_if:\n # Skip this case since traffic would be switched outside fabric\n continue\n for filter_entry in contract.get_all_filter_entries():\n for i in range(0, num_flows_per_entry):\n flow = Flow()\n flow.ethertype = filter_entry.etherT\n if flow.ethertype == 'arp':\n flow.arp_opcode = filter_entry.arpOpc\n flow.populate_random_ip_addresses()\n elif flow.ethertype == 'ip':\n flow.populate_random_ip_addresses()\n flow.proto = filter_entry.prot\n if flow.proto == '6' or flow.proto == '17':\n dFromPort = int(filter_entry.dFromPort)\n dToPort = int(filter_entry.dToPort)\n sFromPort = int(filter_entry.sFromPort)\n sToPort = int(filter_entry.sToPort)\n if dFromPort == 0:\n dFromPort = 1\n dToPort += 1\n if sFromPort == 0:\n sFromPort = 1\n sToPort += 1\n if dToPort > 65534:\n dToPort = 65534\n if sToPort > 65534:\n sToPort = 65534\n flow.dport = str(random_number(dFromPort,\n dToPort))\n flow.sport = str(random_number(sFromPort,\n sToPort))\n if flow.proto == '6':\n flow.tcp_rules = filter_entry.tcpRules\n flow.svlan = providing_vlan\n flow.dvlan = consuming_vlan\n flow.src_intf = providing_phys_if\n flow.dst_intf = consuming_phys_if\n\n # Is the flow expected to succeed ?\n flow.expected_action = 'drop'\n providing_bd = providing_epg.get_bd()\n consuming_bd = consuming_epg.get_bd()\n if providing_bd and consuming_bd:\n if providing_bd == consuming_bd:\n if providing_bd.get_context() == consuming_bd.get_context():\n flow.expected_action = 'permit'\n flow.populate_random_mac_addresses()\n flows.append(flow)\n return flows","def compute_shortest_routes(start_ids, dest_ids, G):\n return ox.distance.shortest_path(G, start_ids, dest_ids, weight='travel_time', cpus=6)","def shortest_steps(connectors: List[int]):\n connectors = sorted(connectors)\n return [nxt-prv for prv, nxt in zip([0]+connectors, connectors)] + [3]","def shortest_path_bfs_list_list(dic_adj_graph, source_list, destination_list):\r\n\tvisited = set()\r\n\tqueue = collections.deque([])\r\n\tfor node in source_list:\r\n\t visited.add((node, node))\r\n\t queue.append((node, 0, node))\r\n\tjumps_list = [] # To store the number of jumps of each node in desination_list\r\n\r\n\t# Repeat until queue is empty\r\n\twhile queue: \r\n\t vertex = queue.popleft() # 0:node - 1:level - 2:initial_node\r\n\t # If vertex is destionation return level\r\n\t if vertex[0] in destination_list:\r\n\t jumps_list.append(vertex[1])\r\n\t # Add to visited and append to queue\r\n\t for neighbour in dic_adj_graph[vertex[0]]: \r\n\t if (neighbour, vertex[2]) not in visited: \r\n\t visited.add((neighbour, vertex[2])) \r\n\t queue.append((neighbour, vertex[1]+1, vertex[2])) \r\n\treturn jumps_list","def genChunkTestSets(data, nSets, ws, gapSize, dirName=\"test_data/\", ofCut=0.9):\n # Start times for windows with at least ofCut of data observed\n tOFCut = np.where(windowObsFrac(data, ws) > ofCut)[0]\n\n # Choose times for test intervals\n np.random.seed(np.random.randint(0, 100))\n sampleTs = np.random.choice(tOFCut, size=nSets, replace=False)\n\n for ti in sampleTs:\n # Randomly select a sensor\n sensor = np.random.randint(0, data.shape[1])\n # Remove some data to use for testing\n _, removedTimes = removeChunk(data, ti, ws, sensor, gapSize)\n\n # Save data in csvs\n np.savetxt(dirName + \"/ti=%i_tf=%i_sensor=%i.csv\"%(ti, ti+ws, sensor), removedTimes, \\\n delimiter=\" \", fmt=\"%i\")","def random_path(length):\n assert length > 0\n edges = [Variable('ve%d' % i) for i in range(1, length + 1)]\n nodes = [Variable('vn%d' % i) for i in range(1, length)] + [TARGET_VAR]\n s = SOURCE_VAR # start at source\n triples = []\n for e, n in zip(edges, nodes):\n triples.append((s, e, n))\n s = n\n gp = GraphPattern([\n (o, p, s) if random.random() < .5 else (s, p, o)\n for s, p, o in triples\n ])\n return gp","def generate_visiting_scheme(self):\n\n def all_indices_shuffled():\n _res = list(range(self.dataset.num_examples))\n self.rnd.shuffle(_res)\n return _res\n\n # noinspection PyUnusedLocal\n _tmp_ts = np.concatenate(\n [all_indices_shuffled() for _ in range(self.epochs or 1)]\n )\n self.training_schedule = (\n _tmp_ts\n if self.training_schedule is None\n else np.concatenate([self.training_schedule, _tmp_ts])\n ) # do not discard previous schedule,\n # this should allow backward passes of arbitrary length\n\n return self","def Generate_edges(size, connectedness):\r\n\r\n assert connectedness <= 1\r\n random.seed(10)\r\n for i in range(size):\r\n for j in range(i + 1, size):\r\n if random.randrange(0, 100) <= connectedness * 100:\r\n yield f'{i} {j}'","def _get_allow_all_flows() -> List[FlowDescription]:\n return [\n # Set flow match for all packets\n # Don't set the app_name field\n FlowDescription( # uplink flow\n match=FlowMatch(\n direction=FlowMatch.Direction.Value(\"UPLINK\"),\n ),\n action=FlowDescription.Action.Value(\"PERMIT\"),\n ),\n FlowDescription( # downlink flow\n match=FlowMatch(\n direction=FlowMatch.Direction.Value(\"DOWNLINK\"),\n ),\n action=FlowDescription.Action.Value(\"PERMIT\"),\n ),\n ]","def connect(src, *destinations, exclude=set(), fit=False):\n assignemnts = []\n for dst in destinations:\n assignemnts.extend(_connect(src, dst, exclude, fit))\n \n return assignemnts","def shuffle(self):\n self.edges = np.random.permutation(self.edges)\n self.batch_num = 0","def generate_parameters_random_walk():\r\n\r\n logging.info('Loading distances_nets from disk...')\r\n\r\n\r\n\r\n sum_weights = {}\r\n\r\n amount_edges = {}\r\n\r\n\r\n\r\n layer = 0\r\n\r\n while is_pickle('distances_nets_weights-layer-' + str(layer)):\r\n\r\n logging.info('Executing layer {}...'.format(layer))\r\n\r\n weights = restore_variable_from_disk('distances_nets_weights-layer-' + str(layer))\r\n\r\n\r\n\r\n for node, list_weights in weights.items():\r\n\r\n if layer not in sum_weights:\r\n\r\n sum_weights[layer] = 0\r\n\r\n if layer not in amount_edges:\r\n\r\n amount_edges[layer] = 0\r\n\r\n\r\n\r\n for w in list_weights:\r\n\r\n sum_weights[layer] += w\r\n\r\n amount_edges[layer] += 1\r\n\r\n\r\n\r\n logging.info('Layer {} executed.'.format(layer))\r\n\r\n layer += 1\r\n\r\n\r\n\r\n average_weight = {}\r\n\r\n for layer in sum_weights.keys():\r\n\r\n average_weight[layer] = sum_weights[layer] / amount_edges[layer]\r\n\r\n\r\n\r\n logging.info(\"Saving average_weights on disk...\")\r\n\r\n save_variable_on_disk(average_weight, 'average_weight')\r\n\r\n\r\n\r\n amount_neighbours = {}\r\n\r\n\r\n\r\n layer = 0\r\n\r\n while is_pickle('distances_nets_weights-layer-' + str(layer)):\r\n\r\n logging.info('Executing layer {}...'.format(layer))\r\n\r\n weights = restore_variable_from_disk('distances_nets_weights-layer-' + str(layer))\r\n\r\n\r\n\r\n amount_neighbours[layer] = {}\r\n\r\n\r\n\r\n for node, list_weights in weights.items():\r\n\r\n cont_neighbours = 0\r\n\r\n for w in list_weights:\r\n\r\n if w > average_weight[layer]:\r\n\r\n cont_neighbours += 1\r\n\r\n amount_neighbours[layer][node] = cont_neighbours\r\n\r\n\r\n\r\n logging.info('Layer {} executed.'.format(layer))\r\n\r\n layer += 1\r\n\r\n\r\n\r\n logging.info(\"Saving amount_neighbours on disk...\")\r\n\r\n save_variable_on_disk(amount_neighbours, 'amount_neighbours')","def traverse_graph(F, f, s, t, u, sr):\n def get_paths_for_flow(F, s, f):\n \"\"\"\n RETURNS\n A set of outgoing links and corresponding splitting ratios for flow f\n at node s\n \"\"\"\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links\n \n if u == t:\n return [([t], sr)]\n\n outgoing_links = get_paths_for_flow(F, u, f)\n paths_to_t = []\n\n for ((current_node, next_hop), split_ratio) in outgoing_links:\n paths_from_u_to_t = traverse_graph(F, f, s, t, next_hop, split_ratio) \n paths_to_t.extend(paths_from_u_to_t)\n\n paths_to_t_with_u = []\n for path in paths_to_t:\n nodes, sr = path\n new_path = [u] + nodes\n paths_to_t_with_u.append((new_path, sr))\n\n return paths_to_t_with_u","def generate(\n self,\n num_nodes_src_set: int,\n num_nodes_dst_set: int,\n num_edges_src_dst: int,\n num_edges_dst_src: int,\n is_directed: bool,\n return_node_ids: bool = False,\n transform_graph: bool = True,\n *args,\n **kwargs,\n ):\n raise NotImplementedError()","def djikstra(self, source, target):\r\n dist = {}\r\n prev = {}\r\n set_q = {}\r\n for vertex in self.vertices.keys():\r\n dist[vertex] = sys.maxsize\r\n prev[vertex] = None\r\n set_q[vertex] = dist[vertex]\r\n dist[source] = 0\r\n set_q[source] = 0\r\n while set_q:\r\n vertex_u = min(set_q, key=set_q.get)\r\n if vertex_u == target:\r\n break\r\n set_q.pop(vertex_u)\r\n for edge in self.edges[vertex_u]:\r\n alt = dist[vertex_u] + edge.distance\r\n if alt < dist[edge.destination]:\r\n dist[edge.destination] = alt\r\n set_q[edge.destination] = dist[edge.destination]\r\n prev[edge.destination] = vertex_u\r\n path = []\r\n vertex_u = target\r\n while prev[vertex_u]:\r\n path.insert(0, vertex_u)\r\n vertex_u = prev[vertex_u]\r\n path.insert(0, vertex_u)\r\n return path","def min_path(vs, es, source, target):\n dijkstra(vs, es, source, stop = target)\n test = target\n result = []\n while test != source:\n e = test._ss_edge\n result.append(e)\n test = e.v1 if e.v1 != test else e.v2\n assert test == source and test._ss_edge is None\n return result[::-1]","def _get_paths(G, nodes, edges, target, weight, available_dist, cache={}):\n\n G_succ = G.succ if G.is_directed() else G.adj\n\n output = []\n visited = set(nodes)\n path_info = []\n source = nodes[-1]\n get_weight = _create_weight_func(G, weight)\n\n for neighbor, neighbor_edge in G_succ[source].items():\n\n if neighbor in visited:\n continue\n\n new_available_dist = available_dist - get_weight(source, neighbor)\n\n if new_available_dist < 0:\n continue\n\n # shortest path key for cache\n sp_key = (source, neighbor, target)\n\n if sp_key not in cache:\n sp = dijkstra(G, neighbor, target, 'length', set([source]), \n new_available_dist)\n\n cache[sp_key] = INF if not sp else sp[1]\n\n if new_available_dist < cache[sp_key]:\n continue\n\n path_info.append((neighbor, neighbor_edge, new_available_dist))\n\n\n for (neighbor, neighbor_edge, new_available_dist) in path_info:\n new_path = nodes + [neighbor]\n new_edges = edges + [neighbor_edge]\n\n if neighbor == target:\n output.append((new_path, new_edges))\n else:\n output.extend(_get_paths(G, new_path, new_edges, target, \n weight, new_available_dist, cache))\n\n return output","def sample_edge_uniform(adj_list, degrees, n_triplets, sample_size):\n all_edges = np.arange(n_triplets)\n return np.random.choice(all_edges, sample_size, replace=False)","def get_diffuse_sources(self, src_sel):\n extended = self._select_and_freeze(self.extended_sources, src_sel)\n for s in extended: # this seems redundant, but was necessary\n s.model.free[:] = False if src_sel.frozen(s) else s.free[:]\n sources.validate(s,self.nside, None)\n s.smodel = s.model\n \n return self.get_global_sources(src_sel.skydir()), extended","def select_seeds(self, graph, k):\n raise NotImplementedError\n return set()","def testSierpinski(self):\n G = self.twistedLadder(4) # Complete graph on four vertices\n for i in range(3):\n G = self.truncate(G)\n self.check(G,3)","def shortestPath(self, source, target):\n dist = {}\n prev = {}\n q = []\n for y,a in enumerate(self.sm):\n for x,b in enumerate(self.sm[y]):\n dist[(x,y)] = sys.maxint\n prev[(x,y)] = None\n q.append((x,y))\n dist[source] = 0\n\n while len(q) is not 0:\n # find the node with minimum value (u)\n d = deepcopy(dist)\n while True:\n b = dict(map(lambda item: (item[1],item[0]), d.items()))\n u = b[min(b.keys())]\n if u not in q:\n d.pop(u)\n else:\n break\n\n if dist[u] == sys.maxint: # remaining nodes are inaccessible\n break\n\n q.remove(u)\n\n\n if u == target: # target found\n break\n\n for v in self.getNeighbors(u):\n alt = dist[u] + 1\n if alt < dist[v]:\n dist[v] = alt\n prev[v] = u\n\n s = []\n u = target\n while prev[u] is not None:\n s.append(u)\n u = prev[u]\n s.reverse()\n\n return s","def transfer_funds_randomly():\n\n source_id = get_random_account_id()\n sink_id = get_random_account_id()\n\n source = Account.get(id=source_id)\n amount = floor(source.balance / 2)\n\n if source.balance < amount:\n raise \"Insufficient funds\"\n\n source.balance -= amount\n sink = Account.get(id=sink_id)\n sink.balance += amount","def prepare_k_fold(self, k_fold: int, shuffle: bool = True) \\\n -> List[Tuple[ZLIMGS, ZLIMGS, ZLIMGS, ZLIMGS, ZLIMGS, ZLIMGS]]:\n if self.setting == 'setting1':\n warnings.warn(\"Setting 1 should not use train eval dataset! \"\n \"Because its training set only contain normal samples!\")\n\n with open(self.json_path) as fp:\n ids_json = json.load(fp)\n ids_train_normal = ids_json['normal']['train']\n ids_train_defect = ids_json['defect']['train']\n\n if shuffle:\n self.rnd.shuffle(ids_train_normal)\n self.rnd.shuffle(ids_train_defect)\n ids_folds_normal = chunks(ids_train_normal, k_fold)\n ids_folds_defect = chunks(ids_train_defect, k_fold)\n\n zlimgs_folds = []\n for k in range(k_fold):\n _ids_folds_normal = ids_folds_normal.copy()\n _ids_folds_defect = ids_folds_defect.copy()\n ids_k_dev_normal = _ids_folds_normal.pop(k)\n ids_k_dev_defect = _ids_folds_defect.pop(k)\n ids_k_train_normal = list(itertools.chain(*_ids_folds_normal))\n ids_k_train_defect = list(itertools.chain(*_ids_folds_defect))\n\n # train\n zlimgs_k_train_normal = self._create_zl_imgs_given_ids(ids=ids_k_train_normal,\n subset=CONFIG[self.setting]['normal_train'],\n ann_type=CONFIG[self.setting]['ann_train'])\n zlimgs_k_train_defect = self._create_zl_imgs_given_ids(ids=ids_k_train_defect,\n subset=CONFIG[self.setting]['defect_train'],\n ann_type=CONFIG[self.setting]['ann_train'])\n # train-eval\n zlimgs_k_train_eval_normal = self._create_zl_imgs_given_ids(ids=ids_k_train_normal,\n subset=CONFIG[self.setting]['normal_train'],\n ann_type=CONFIG[self.setting]['ann_eval'])\n zlimgs_k_train_eval_defect = self._create_zl_imgs_given_ids(ids=ids_k_train_defect,\n subset=CONFIG[self.setting]['defect_train'],\n ann_type=CONFIG[self.setting]['ann_eval'])\n # dev\n zlimgs_k_dev_normal = self._create_zl_imgs_given_ids(ids=ids_k_dev_normal, subset='dev',\n ann_type=CONFIG[self.setting]['ann_eval'])\n zlimgs_k_dev_defect = self._create_zl_imgs_given_ids(ids=ids_k_dev_defect, subset='dev',\n ann_type=CONFIG[self.setting]['ann_eval'])\n zlimgs_folds.append((zlimgs_k_train_normal, zlimgs_k_train_defect,\n zlimgs_k_train_eval_normal, zlimgs_k_train_eval_defect,\n zlimgs_k_dev_normal, zlimgs_k_dev_defect))\n return zlimgs_folds","def shuffle(self):\n for edge_type in self.edge_types:\n for k in range(self.edge_types[edge_type]):\n self.train_edges[edge_type][k] = np.random.permutation(self.train_edges[edge_type][k])\n self.batch_num[self.edge_type2idx[edge_type[0], edge_type[1], k]] = 0\n self.current_edge_type_idx = 0\n self.freebatch_edge_types = list(range(self.num_edge_types))\n self.freebatch_edge_types.remove(self.edge_type2idx[0, 0, 0])\n self.freebatch_edge_types.remove(self.edge_type2idx[0, 1, 0])\n self.freebatch_edge_types.remove(self.edge_type2idx[1, 0, 0])\n self.iter = 0","def FixedInGraph(N,degrees,replace = True):\n \n conn = np.zeros([N*degrees,2])\n nodes = np.arange(0,N)\n ii = 0\n for i in range(N):\n # for deg in range(degrees):\n source = np.random.choice(nodes,size =degrees,replace=replace)\n conn[ii:ii+len(source),0] = source\n conn[ii:ii+len(source),1] = i\n ii+=len(source) \n return conn"],"string":"[\n \"def compute_equal_flow_allocations(target_graph, K=3):\\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\\n flow_allocation_seed_number = 0xDEAD_BEEF\\n np.random.seed(flow_allocation_seed_number)\\n flows = []\\n for node in target_graph.nodes:\\n possible_destination_nodes = set(target_graph.nodes) - set([node])\\n [destination_node] = np.random.choice(list(possible_destination_nodes), 1, replace=False)\\n # shortest_paths = all_shortest_paths(target_graph, node, destination_node.item())\\n shortest_paths = sorted(nx.all_simple_paths(target_graph, node, destination_node.item(),\\n cutoff=3),\\n key=lambda p: len(p))\\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\\n the_flow = Flow( source_node = node\\n , destination_node = destination_node.item()\\n , flow_tx_rate = 10.0\\n , paths = k_shortest_paths\\n , splitting_ratio = [1/K]*K\\n )\\n flows.append(the_flow)\\n \\n return flow_allocation_seed_number, flows\",\n \"def bfsSample(G, source=None, k = 50):\\n\\twarn(\\\"networkit.sampling.bfsSample is deprecated, will be removed in future updates.\\\")\\n\\tif not source:\\n\\t\\tsource = GraphTools.randomNode(G)\\n\\tn = G.numberOfNodes()\\n\\tvisited = [False]*n\\n\\tQ = [source]\\n\\tclosest = set([source])\\n\\tglobal found\\n\\tfound = 0\\n\\twhile len(Q) > 0 and found < k:\\n\\t\\tu = Q.pop(0)\\n\\t\\tdef enqueue(u,v,weight, eid):\\n\\t\\t\\tglobal found\\n\\t\\t\\tif not visited[v] and found < k:\\n\\t\\t\\t\\tfound += 1\\n\\t\\t\\t\\tvisited[v] = True\\n\\t\\t\\t\\tQ.append(v)\\n\\t\\t\\t\\tclosest.add(v)\\n\\t\\tG.forEdgesOf(u, enqueue)\\n\\tprint(\\\"found {0} nodes\\\".format(len(closest)))\\n\\tG1 = GraphTools.subgraphFromNodes(G, closest)\\n\\treturn G1\",\n \"def compute_greedy_flow_allocations( target_graph\\n , flow_selection_fn\\n , seed_number=DEFAULT_SEED_NUMBER):\\n\\n flow_allocation_seed_number = seed_number\\n np.random.seed(flow_allocation_seed_number)\\n\\n link_utilization = {tuple(sorted(link_tuple)): 0.0 for link_tuple in target_graph.edges}\\n flows = []\\n\\n while True:\\n capacity_was_exceeded = False\\n\\n source_node, destination_node = flow_selection_fn(target_graph.nodes)\\n flow_tx_rate = np.random.uniform(FLOW_TX_RATE_LOWER_BOUND, FLOW_TX_RATE_UPPER_BOUND)\\n\\n connecting_paths = list(node_disjoint_paths(target_graph, source_node, destination_node))\\n disjoint_path_count = len(connecting_paths)\\n flow_rate_per_subpath = flow_tx_rate / disjoint_path_count\\n for path in [nx.utils.pairwise(p_i) for p_i in connecting_paths]:\\n for u, v in [tuple(sorted(t_i)) for t_i in path]:\\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\\n capacity_was_exceeded = True\\n break\\n link_utilization[u, v] += flow_rate_per_subpath\\n if capacity_was_exceeded:\\n break\\n if capacity_was_exceeded:\\n break\\n\\n the_flow = Flow( source_node = source_node\\n , destination_node = destination_node\\n , flow_tx_rate = flow_tx_rate\\n , paths = connecting_paths\\n , splitting_ratio = [1.0/disjoint_path_count]*disjoint_path_count\\n )\\n flows.append(the_flow)\\n return flows, link_utilization\",\n \"def compute_unequal_flow_allocations(target_graph, K=3):\\n\\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\\n flow_allocation_seed_number = 0xDEAD_BEEF\\n np.random.seed(flow_allocation_seed_number)\\n flows = []\\n link_utilization = {}\\n for node in target_graph.nodes:\\n possible_destination_nodes = set(target_graph.nodes) - {node}\\n destination_node = np.random.choice(list(possible_destination_nodes), 1, \\n replace=False).item()\\n shortest_path = nx.shortest_path(target_graph, node, destination_node)\\n the_flow = Flow( source_node = node\\n , destination_node = destination_node\\n , flow_tx_rate = 10.0\\n , paths = [shortest_path]\\n , splitting_ratio = [1.0]\\n )\\n flows.append(the_flow)\\n\\n return flow_allocation_seed_number, flows\",\n \"def __generate_all_shortest_paths(self,cutoff = 10):\\n if cutoff < 1:\\n cutoff = 10\\n self.__logger.info(\\\"cutoff value must be a positive integer. Set back to default value: 10\\\")\\n\\n all_pair_shortest_paths = nx.all_pairs_shortest_path(self.G, cutoff=cutoff)\\n for item in all_pair_shortest_paths:\\n from_node = item[0]\\n paths = item[1]\\n for destination,path in paths.items():\\n yield (len(path),path)\",\n \"def get_paths_for_flow(F, s, f):\\n links = [((u, v), split_ratio) \\n for (flow_id, u, v), split_ratio in F.items() \\n if flow_id == f and u == s and split_ratio > 0.001]\\n return links\",\n \"def get_paths_for_flow(F, s, f):\\n links = [((u, v), split_ratio) \\n for (flow_id, u, v), split_ratio in F.items() \\n if flow_id == f and u == s and split_ratio > 0.001]\\n return links\",\n \"def generate_graph(size, number_of_clusters, minimal_size):\\n base_list = list(range(size))\\n result_list = []\\n random.shuffle(base_list)\\n for i in range(number_of_clusters - 1):\\n size = random.randint(minimal_size, len(base_list) - (number_of_clusters - i - 1) * minimal_size)\\n cluster = []\\n for n in range(size):\\n actual = random.choice(base_list)\\n base_list.remove(actual)\\n cluster.append(actual)\\n result_list.append(strongly_connect(cluster))\\n result_list.append(strongly_connect(base_list))\\n\\n while len(result_list) < 5:\\n result_list.append([])\\n\\n print(sorted([len(i) for i in result_list], reverse=True)[:5])\\n\\n return weak_connect_graph(result_list)\",\n \"def get_pathologic_covering_routes(n_pl, n_target, attacker_strategy, target_values):\\n # computes the coefficient used by the greedy oracle to choose routes\\n targets_coeff = np.transpose(np.multiply(attacker_strategy, target_values))\\n\\n # randomly selects the player for which the non optimal choice will be made\\n wrong_pl = randint(1, n_pl)\\n\\n # generate the non optimal route randomly\\n n_covered_targets = randint(n_pl,n_target-1)\\n non_opt_action = np.zeros(n_target)\\n for i in range(0, n_covered_targets):\\n random_covered_target = randint(0, n_target-1)\\n non_opt_action[random_covered_target] = 1\\n\\n # compute the value of the non optimal route\\n non_opt_val = get_value_single_route(non_opt_action, targets_coeff)\\n\\n # generate routes that have, as a single, values smaller than the best greedy route but taken togher perform\\n # at least as well. [[0,1,...],[...],...] a[r][t]=1 iff t is covered by r.\\n # The returned list should have n_pl - 1 routes\\n opt_routes = get_opt_routes(n_pl, non_opt_action)\\n\\n I={}\\n for pl in range(1, n_pl+1):\\n\\n n_r = randint(0, MAX_ROUTES)\\n temp = lil_matrix((n_r+1, n_target), dtype='int8')\\n\\n if pl == wrong_pl:\\n # put the non opt route in the bucket\\n for t in non_opt_action.nonzero():\\n temp[0,t] = 1\\n else:\\n for t in opt_routes.pop().nonzero():\\n temp[0,t] = 1\\n\\n # generate other random routes with single value less than the non_opt_value\\n for r in range(1, n_r):\\n new_route = get_r_limited_val(non_opt_val, targets_coeff)\\n\\n for t in new_route.nonzero():\\n temp[r,t] = 1\\n\\n I[pl] = temp.tocsr()\\n\\n return I\",\n \"def multipleTravellingSalesmen(self, iterations=None):\\n if not iterations:\\n iterations = self.mTSPIterations\\n\\n # Randomly select points drawn from unvisited and distribute equally among the ships\\n paths = self.partition(self.unvisited.keys(), len(self.ships))\\n [path.append(ship) for path, ship in zip(paths, self.ships)]\\n\\n # Run single travelling salesman on each of the ships\\n paths = [self.singleTravellingSalesman(path, iterations=0) for path in paths]\\n\\n\\n # IF TWO OR MORE SHIPS!!!\\n # Point exchange between ships and rerun tsp on each ship\\n if len(self.ships) > 1:\\n for _ in range(iterations):\\n twopathindices = random.sample(xrange(len(paths)), 2)\\n newtwopaths = self.swapTwoPointsBetweenPaths([paths[index] for index in twopathindices])\\n newtwopaths = [self.singleTravellingSalesman(path, iterations=max(len(path), 100)) for path in\\n newtwopaths]\\n if self.totalPathDistance(newtwopaths) < self.totalPathDistance(\\n [paths[index] for index in twopathindices]):\\n for i, index in enumerate(twopathindices):\\n paths[index] = newtwopaths[i]\\n\\n return paths\",\n \"def set_random_session(self, G, degree_s):\\n sorted_nodes = nx.topological_sort(G)\\n num_nodes = G.number_of_nodes()\\n\\n # create sources and destinations of each of the sections\\n # name the nodes to be the last 4 numbers\\n srcs = [num_nodes, num_nodes + 1]\\n dsts = [num_nodes + 2, num_nodes + 3]\\n\\n end_idx = int(0.3 * len(sorted_nodes))\\n end_idx = max(end_idx, 2)\\n for i in range(2):\\n s = srcs[i]\\n t = dsts[i]\\n reachables = []\\n iter_num = 0\\n\\n while len(reachables) == 0:\\n iter_num += 1\\n if iter_num > 100:\\n end_idx = end_idx * 2\\n\\n # pick an entry point from the first 30%\\n entry_point = random.choice(sorted_nodes[:end_idx])\\n # print \\\"Source \\\", i\\n # print \\\"candidates: \\\", sorted_nodes[:end_idx]\\n # print \\\"entry point: \\\", entry_point\\n # print \\\"all nodes: \\\", G.nodes()\\n\\n # pick a random point from the reachables\\n reachables = nx.shortest_path(G, entry_point)\\n del reachables[entry_point]\\n #print \\\"reachables: \\\", reachables\\n reachables = reachables.keys()\\n\\n exit_point = random.choice(reachables)\\n #print \\\"exit_point: \\\", exit_point\\n\\n if degree_s[i]:\\n G.add_edge(s, entry_point, weight=degree_s[i])\\n G.add_edge(exit_point, t, weight=degree_s[i])\\n else:\\n # figure out the out_degree of entry point\\n out_degree = np.sum(G[u][v]['weight'] for u,v in G.out_edges(entry_point))\\n G.add_edge(s, entry_point, weight=out_degree)\\n\\n # figure out the int_degree of exit point\\n in_degree = np.sum(G[u][v]['weight'] for u,v in G.in_edges(exit_point))\\n G.add_edge(exit_point, t, weight=in_degree)\\n\\n edges = G.edges()\\n for u, v in edges:\\n par_num = int(G[u][v]['weight'])\\n for i in range(par_num):\\n self.add_edge(u, v)\\n\\n # set indices etc\\n self.set_sources(srcs)\\n self.set_destinations(dsts)\\n self.set_indices()\\n #print \\\"number of nodes: \\\" + str(self.number_of_nodes())\\n #print \\\"number of edges: \\\" + str(self.number_of_edges())\",\n \"def get_k_shortest_paths(env: RailEnv,\\n source_position: Tuple[int, int],\\n source_direction: int,\\n target_position=Tuple[int, int],\\n k: int = 1, debug=False) -> List[Tuple[Waypoint]]:\\n\\n # P: set of shortest paths from s to t\\n # P =empty,\\n shortest_paths: List[Tuple[Waypoint]] = []\\n\\n # countu: number of shortest paths found to node u\\n # countu = 0, for all u in V\\n count = {(r, c, d): 0 for r in range(env.height) for c in range(env.width) for d in range(4)}\\n\\n # B is a heap data structure containing paths\\n # N.B. use OrderedSet to make result deterministic!\\n heap: OrderedSet[Tuple[Waypoint]] = OrderedSet()\\n\\n # insert path Ps = {s} into B with cost 0\\n heap.add((Waypoint(source_position, source_direction),))\\n\\n # while B is not empty and countt < K:\\n while len(heap) > 0 and len(shortest_paths) < k:\\n if debug:\\n print(\\\"iteration heap={}, shortest_paths={}\\\".format(heap, shortest_paths))\\n # – let Pu be the shortest cost path in B with cost C\\n cost = np.inf\\n pu = None\\n for path in heap:\\n if len(path) < cost:\\n pu = path\\n cost = len(path)\\n u: Waypoint = pu[-1]\\n if debug:\\n print(\\\" looking at pu={}\\\".format(pu))\\n\\n # – B = B − {Pu }\\n heap.remove(pu)\\n # – countu = countu + 1\\n\\n urcd = (*u.position, u.direction)\\n count[urcd] += 1\\n\\n # – if u = t then P = P U {Pu}\\n if u.position == target_position:\\n if debug:\\n print(\\\" found of length {} {}\\\".format(len(pu), pu))\\n shortest_paths.append(pu)\\n\\n # – if countu ≤ K then\\n # CAVEAT: do not allow for loopy paths\\n elif count[urcd] <= k:\\n possible_transitions = env.rail.get_transitions(*urcd)\\n if debug:\\n print(\\\" looking at neighbors of u={}, transitions are {}\\\".format(u, possible_transitions))\\n # for each vertex v adjacent to u:\\n for new_direction in range(4):\\n if debug:\\n print(\\\" looking at new_direction={}\\\".format(new_direction))\\n if possible_transitions[new_direction]:\\n new_position = get_new_position(u.position, new_direction)\\n if debug:\\n print(\\\" looking at neighbor v={}\\\".format((*new_position, new_direction)))\\n\\n v = Waypoint(position=new_position, direction=new_direction)\\n # CAVEAT: do not allow for loopy paths\\n if v in pu:\\n continue\\n\\n # – let Pv be a new path with cost C + w(u, v) formed by concatenating edge (u, v) to path Pu\\n pv = pu + (v,)\\n # – insert Pv into B\\n heap.add(pv)\\n\\n # return P\\n return shortest_paths\",\n \"def stochastic_event_set(\\n sources, source_site_filter=filters.source_site_noop_filter):\\n for source, s_sites in source_site_filter(sources):\\n try:\\n for rupture in source.iter_ruptures():\\n for i in range(rupture.sample_number_of_occurrences()):\\n yield rupture\\n except Exception as err:\\n etype, err, tb = sys.exc_info()\\n msg = 'An error occurred with source id=%s. Error: %s'\\n msg %= (source.source_id, str(err))\\n raise_(etype, msg, tb)\",\n \"def ford_fulkerson_algorithm(graph: np.ndarray, source: int, sink: int) -> np.ndarray:\\r\\n\\r\\n residual_graph = copy.deepcopy(graph)\\r\\n row = len(residual_graph)\\r\\n parent = [-1] * row\\r\\n max_flow = 0\\r\\n\\r\\n if source == sink or sink < 0 or source < 0 or source >= row or sink >= row:\\r\\n raise WrongInputException('Wrong input source/sink vertice(s)')\\r\\n\\r\\n while bfs(residual_graph, row, source, sink, parent):\\r\\n\\r\\n path_flow = float(\\\"Inf\\\")\\r\\n s = sink\\r\\n while s != source:\\r\\n path_flow = min(path_flow, residual_graph[parent[s]][s])\\r\\n s = parent[s]\\r\\n\\r\\n max_flow += path_flow\\r\\n\\r\\n v = sink\\r\\n while v != source:\\r\\n u = parent[v]\\r\\n residual_graph[u][v] -= path_flow\\r\\n residual_graph[v][u] += path_flow\\r\\n v = parent[v]\\r\\n print(\\\"Max flow: %d\\\" % max_flow)\\r\\n\\r\\n return residual_graph\",\n \"def run_random_annealing(tsp_file, T, scheme, N_sim, max_chain_length=100000, c=.95):\\n # create empty lists for to be stored values\\n best_routes, costs, cost_lists = [], [], []\\n\\n adjacency_matrix = make_matrix(tsp_file)\\n\\n for _ in range(N_sim):\\n # generate random initial route\\n x = list(range(len(adjacency_matrix)))\\n init_route = random.sample(x,len(x))\\n \\n # find best route with SA algorithm\\n best_route, cost_list = tsp_annealing_random(T, scheme, init_route, adjacency_matrix, max_chain_length, c)\\n\\n # append all values from simulation to lists\\n costs.append(calculate_cost(best_route,adjacency_matrix)[1])\\n best_routes.append(best_route)\\n cost_lists.append(cost_list)\\n\\n return best_routes, costs, cost_lists\",\n \"def k_shortest_paths(G, source, target, k=1, weight='weight'):\\n\\tif source == target:\\n\\t\\treturn ([0], [[source]]) \\n\\t \\n\\tlength, path = nx.single_source_dijkstra(G, source, target, weight=weight)\\n\\tif target not in length:\\n\\t\\traise nx.NetworkXNoPath(\\\"node %s not reachable from %s\\\" % (source, target))\\n\\t\\t\\n\\tlengths = [length[target]]\\n\\tpaths = [path[target]]\\n\\tc = count()\\t\\t\\n\\tB = []\\t\\t\\t\\t\\t\\t\\n\\tG_original = G.copy()\\t\\n\\t\\n\\tfor i in range(1, k):\\n\\t\\tfor j in range(len(paths[-1]) - 1):\\t\\t\\t\\n\\t\\t\\tspur_node = paths[-1][j]\\n\\t\\t\\troot_path = paths[-1][:j + 1]\\n\\t\\t\\t\\n\\t\\t\\tedges_removed = []\\n\\t\\t\\tfor c_path in paths:\\n\\t\\t\\t\\tif len(c_path) > j and root_path == c_path[:j + 1]:\\n\\t\\t\\t\\t\\tu = c_path[j]\\n\\t\\t\\t\\t\\tv = c_path[j + 1]\\n\\t\\t\\t\\t\\tif G.has_edge(u, v):\\n\\t\\t\\t\\t\\t\\tedge_attr = G.edge[u][v]\\n\\t\\t\\t\\t\\t\\tG.remove_edge(u, v)\\n\\t\\t\\t\\t\\t\\tedges_removed.append((u, v, edge_attr))\\n\\t\\t\\t\\n\\t\\t\\tfor n in range(len(root_path) - 1):\\n\\t\\t\\t\\tnode = root_path[n]\\n\\t\\t\\t\\t# out-edges\\n\\t\\t\\t\\tfor u, v, edge_attr in G.copy().edges_iter(node, data=True):\\n\\t\\t\\t\\t\\tG.remove_edge(u, v)\\n\\t\\t\\t\\t\\tedges_removed.append((u, v, edge_attr))\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif G.is_directed():\\n\\t\\t\\t\\t\\t# in-edges\\n\\t\\t\\t\\t\\tfor u, v, edge_attr in G.in_edges_iter(node, data=True):\\n\\t\\t\\t\\t\\t\\tG.remove_edge(u, v)\\n\\t\\t\\t\\t\\t\\tedges_removed.append((u, v, edge_attr))\\n\\t\\t\\t\\n\\t\\t\\tspur_path_length, spur_path = nx.single_source_dijkstra(G, spur_node, target, weight=weight)\\t\\t\\t\\n\\t\\t\\tif target in spur_path and spur_path[target]:\\n\\t\\t\\t\\ttotal_path = root_path[:-1] + spur_path[target]\\n\\t\\t\\t\\ttotal_path_length = get_path_length(G_original, root_path, weight) + spur_path_length[target]\\t\\t\\t\\t\\n\\t\\t\\t\\theappush(B, (total_path_length, next(c), total_path))\\n\\t\\t\\t\\t\\n\\t\\t\\tfor e in edges_removed:\\n\\t\\t\\t\\tu, v, edge_attr = e\\n\\t\\t\\t\\tG.add_edge(u, v, edge_attr)\\n\\t\\t\\t\\t\\t \\n\\t\\tif B:\\n\\t\\t\\t(l, _, p) = heappop(B)\\n\\t\\t\\tlengths.append(l)\\n\\t\\t\\tpaths.append(p)\\n\\t\\telse:\\n\\t\\t\\tbreak\\n\\t\\n\\treturn (lengths, paths)\",\n \"def k_shortest_paths(G, source, target, k=1, weight='weight'):\\n\\tif source == target:\\n\\t\\treturn ([0], [[source]]) \\n\\t \\n\\tlength, path = nx.single_source_dijkstra(G, source, target, weight=weight)\\n\\tif target not in length:\\n\\t\\traise nx.NetworkXNoPath(\\\"node %s not reachable from %s\\\" % (source, target))\\n\\t\\t\\n\\tlengths = [length[target]]\\n\\tpaths = [path[target]]\\n\\tc = count()\\t\\t\\n\\tB = []\\t\\t\\t\\t\\t\\t\\n\\tG_original = G.copy()\\t\\n\\t\\n\\tfor i in range(1, k):\\n\\t\\tfor j in range(len(paths[-1]) - 1):\\t\\t\\t\\n\\t\\t\\tspur_node = paths[-1][j]\\n\\t\\t\\troot_path = paths[-1][:j + 1]\\n\\t\\t\\t\\n\\t\\t\\tedges_removed = []\\n\\t\\t\\tfor c_path in paths:\\n\\t\\t\\t\\tif len(c_path) > j and root_path == c_path[:j + 1]:\\n\\t\\t\\t\\t\\tu = c_path[j]\\n\\t\\t\\t\\t\\tv = c_path[j + 1]\\n\\t\\t\\t\\t\\tif G.has_edge(u, v):\\n\\t\\t\\t\\t\\t\\tedge_attr = G.edge[u][v]\\n\\t\\t\\t\\t\\t\\tG.remove_edge(u, v)\\n\\t\\t\\t\\t\\t\\tedges_removed.append((u, v, edge_attr))\\n\\t\\t\\t\\n\\t\\t\\tfor n in range(len(root_path) - 1):\\n\\t\\t\\t\\tnode = root_path[n]\\n\\t\\t\\t\\t# out-edges\\n\\t\\t\\t\\tfor u, v, edge_attr in G.copy().edges_iter(node, data=True):\\n\\t\\t\\t\\t\\tG.remove_edge(u, v)\\n\\t\\t\\t\\t\\tedges_removed.append((u, v, edge_attr))\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif G.is_directed():\\n\\t\\t\\t\\t\\t# in-edges\\n\\t\\t\\t\\t\\tfor u, v, edge_attr in G.in_edges_iter(node, data=True):\\n\\t\\t\\t\\t\\t\\tG.remove_edge(u, v)\\n\\t\\t\\t\\t\\t\\tedges_removed.append((u, v, edge_attr))\\n\\t\\t\\t\\n\\t\\t\\tspur_path_length, spur_path = nx.single_source_dijkstra(G, spur_node, target, weight=weight)\\t\\t\\t\\n\\t\\t\\tif target in spur_path and spur_path[target]:\\n\\t\\t\\t\\ttotal_path = root_path[:-1] + spur_path[target]\\n\\t\\t\\t\\ttotal_path_length = get_path_length(G_original, root_path, weight) + spur_path_length[target]\\t\\t\\t\\t\\n\\t\\t\\t\\theappush(B, (total_path_length, next(c), total_path))\\n\\t\\t\\t\\t\\n\\t\\t\\tfor e in edges_removed:\\n\\t\\t\\t\\tu, v, edge_attr = e\\n\\t\\t\\t\\tG.add_edge(u, v, edge_attr)\\n\\t\\t\\t\\t\\t \\n\\t\\tif B:\\n\\t\\t\\t(l, _, p) = heappop(B)\\t\\t\\n\\t\\t\\tlengths.append(l)\\n\\t\\t\\tpaths.append(p)\\n\\t\\telse:\\n\\t\\t\\tbreak\\n\\t\\n\\treturn (lengths, paths)\",\n \"def _select_destination(self):\\n # Ideally this should do something clever based on the start location\\n # ie known trips. But for now, it will pick randomly!\\n station_dict = self.network.station_dict\\n\\n stations = list(station_dict.keys())\\n #stations = [x for x in stations if isinstance(x, int) or x.startswith(\\\"801\\\")]\\n #stations = [x for x in stations if isinstance(x, int) or x.startswith(\\\"80139\\\")]\\n weights = [station_dict[x].in_popularity for x in stations]\\n\\n # pick using the given weight distributions\\n self.dest = random.choices(stations, weights=weights)[0]\\n\\n return\",\n \"def possible(self):\\n return [tuple(path) for path in nx.all_shortest_paths(self._gpm.Graph, source=self.source, target=self.target)]\",\n \"def test_sources():\\n g = Graph(from_list=[\\n (1, 3, 1),\\n (2, 4, 1),\\n (2, 5, 1),\\n (3, 5, 1),\\n (4, 6, 1),\\n (5, 6, 1),\\n ])\\n g.add_node(7)\\n s = g.sources(5)\\n e = {1, 2, 3}\\n assert s == e\\n\\n s2 = g.sources(1)\\n e2 = set()\\n assert s2 == e2, s2\\n\\n s3 = g.sources(6)\\n e3 = {1, 2, 3, 4, 5}\\n assert s3 == e3\\n\\n s4 = g.sources(7)\\n e4 = set()\\n assert s4 == e4\",\n \"def test_heuristic_first_steps(self):\\n graph = {n: set(self.deterministic_graph[n]) - set([n])\\n for n in self.deterministic_graph}\\n deg_heuristic = MinDegreeHeuristic(graph)\\n elim_node = deg_heuristic.best_node(graph)\\n print(\\\"Graph {}:\\\".format(graph))\\n steps = []\\n\\n while elim_node is not None:\\n print(\\\"Removing {}:\\\".format(elim_node))\\n steps.append(elim_node)\\n nbrs = graph[elim_node]\\n\\n for u, v in itertools.permutations(nbrs, 2):\\n if v not in graph[u]:\\n graph[u].add(v)\\n\\n for u in graph:\\n if elim_node in graph[u]:\\n graph[u].remove(elim_node)\\n\\n del graph[elim_node]\\n print(\\\"Graph {}:\\\".format(graph))\\n elim_node = deg_heuristic.best_node(graph)\\n\\n # check only the first 5 elements for equality\\n assert_equals(steps[:5], [0, 1, 2, 3, 4])\",\n \"def get_routing_solution(self):\\n G = self.base_digraph\\n s1 = self.sources[0]\\n s2 = self.sources[1]\\n t1 = self.destinations[0]\\n t2 = self.destinations[1]\\n\\n try:\\n m = Model('routing')\\n m.setParam('OutputFlag', False)\\n\\n # variables,\\n # We have one variable per edge per session\\n # e is the dict of dict for the variables\\n e = {}\\n r = {}\\n for i in [1,2]:\\n e[i] = {}\\n r[i] = m.addVar()\\n for u,v in G.edges():\\n e[i][u,v] = m.addVar(lb=0)\\n\\n m.update()\\n\\n obj = quicksum(r.values())\\n m.setObjective(obj, GRB.MAXIMIZE)\\n\\n # constraints\\n # 1. conservations of flow at all intermediate nodes\\n # 2. capacity constraints for each edge\\n\\n for u,v in G.edges():\\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\\n\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\\n\\n for n in G.nodes():\\n if n not in [s1, s2, t1, t2]:\\n for i in [1, 2]:\\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\\n m.addConstr(inflow == outflow)\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n for u, v in G.edges():\\n G[u][v]['Routing'] = {}\\n G[u][v]['Routing'][1] = e[1][u,v].x\\n G[u][v]['Routing'][2] = e[2][u,v].x\\n return (m.objVal, r[1].x, r[2].x)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong, no optimal solution obtained\\\"\\n return None, None, None\\n\\n except GurobiError:\\n Print ('Error Report from Gurobi')\",\n \"def sampled_clique(clusters,strategy):\\n G = nx.Graph()\\n sample = []\\n #Sample 'size' nodes from a single cluster\\n if strategy == \\\"rand\\\":\\n size = len(clusters)\\n while len(sample) < size:\\n cluster = random.choice(clusters)\\n if len(cluster) >= size:\\n sample = random.sample(cluster,size)\\n #Sample 1 choice from each cluster\\n elif strategy == \\\"optim\\\":\\n for _,cluster in clusters.items():\\n if len(cluster) > 0:\\n sample.append(random.choice(cluster))\\n for n1 in sample:\\n for n2 in sample:\\n if n1 != n2:\\n G.add_edge(n1,n2)\\n return G\",\n \"def random_partition_graph(groups, p_in, p_out, seed=None):\\r\\n\\r\\n if p_in > 1 or p_in < 0:\\r\\n raise errorhandler.ErrorHandler(\\\"p_in must be in [0,1]\\\")\\r\\n\\r\\n if p_out > 1 or p_out < 0:\\r\\n raise errorhandler.ErrorHandler(\\\"p_out must be in [0,1]\\\")\\r\\n\\r\\n size = sum(groups)\\r\\n g = graph.Graph(size, is_partition=True)\\r\\n\\r\\n next_group = {}\\r\\n start = 0\\r\\n group_index = 0\\r\\n for n in groups: # connect nodes inside a group\\r\\n edges = ((u + start, v + start) for u, v in fast_random_graph(n, p_in).edges)\\r\\n g.add_edges(edges)\\r\\n g.partition.append(set(range(start, start+n)))\\r\\n next_group.update(dict.fromkeys(range(start, start + n), start + n))\\r\\n group_index += 1\\r\\n start += n\\r\\n\\r\\n # connect nodes between groups\\r\\n if p_out == 0:\\r\\n return g\\r\\n if p_out == 1:\\r\\n for n in next_group:\\r\\n targets = range(next_group[n], len(g))\\r\\n g.add_edges(zip([n] * len(targets), targets))\\r\\n return g\\r\\n\\r\\n # using method similar to fast_random_graph\\r\\n lp = math.log(1.0 - p_out)\\r\\n n = len(g)\\r\\n\\r\\n for u in range(n - 1):\\r\\n v = next_group[u]\\r\\n while v < n:\\r\\n lr = math.log(1.0 - random.random())\\r\\n v += int(lr / lp)\\r\\n if v < n:\\r\\n g.add_edge(u, v)\\r\\n v += 1\\r\\n\\r\\n return g\",\n \"def k_shortest_paths(\\n self,\\n G,\\n source,\\n target,\\n k=1,\\n weight='weight',\\n ):\\n\\n if source == target:\\n return ([0], [[source]])\\n\\n (length, path) = nx.single_source_dijkstra(G, source, target,\\n weight=weight)\\n if target not in length:\\n raise nx.NetworkXNoPath('node %s not reachable from %s' % (source,\\n target))\\n\\n lengths = [length[target]]\\n paths = [path[target]]\\n c = count()\\n B = []\\n\\n # Is deep copy really required?\\n # Fails due to embedded Ctype objects which can not be pickled\\n # # G_original = G.copy()\\n # Swapping with shallow copy...will it work?\\n\\n G_original = G\\n if nx.is_directed(G_original):\\n G = nx.DiGraph(G_original)\\n else:\\n G = nx.Graph(G_original)\\n\\n ######################################\\n #TODO: wrap this up somehow\\n print ''\\n print term.move_up + term.move_up\\n ######################################\\n print 'getting K:{} paths...'.format(k),\\n for i in range(1, k):\\n with term.location():\\n print i\\n for j in range(len(paths[-1]) - 1):\\n spur_node = paths[-1][j]\\n root_path = (paths[-1])[:j + 1]\\n\\n edges_removed = []\\n for c_path in paths:\\n if len(c_path) > j and root_path == c_path[:j + 1]:\\n u = c_path[j]\\n v = c_path[j + 1]\\n if G.has_edge(u, v):\\n edge_attr = G.edge[u][v]\\n G.remove_edge(u, v)\\n edges_removed.append((u, v, edge_attr))\\n\\n for n in range(len(root_path) - 1):\\n node = root_path[n]\\n\\n # out-edges\\n\\n for (u, v, edge_attr) in G.edges_iter(node, data=True):\\n\\n # print 'lala1: {} -> {}'.format(u,v)\\n\\n G.remove_edge(u, v)\\n edges_removed.append((u, v, edge_attr))\\n\\n if G.is_directed():\\n\\n # in-edges\\n\\n for (u, v, edge_attr) in G.in_edges_iter(node,\\n data=True):\\n\\n # print 'lala2: {} -> {}'.format(u,v)\\n\\n G.remove_edge(u, v)\\n edges_removed.append((u, v, edge_attr))\\n\\n (spur_path_length, spur_path) = nx.single_source_dijkstra(G,\\n spur_node, target, weight=weight)\\n if target in spur_path and spur_path[target]:\\n total_path = root_path[:-1] + spur_path[target]\\n total_path_length = self.get_path_length(G_original,\\n root_path, weight) + spur_path_length[target]\\n heappush(B, (total_path_length, next(c), total_path))\\n\\n for e in edges_removed:\\n (u, v, edge_attr) = e\\n G.add_edge(u, v, edge_attr)\\n\\n if B:\\n (l, _, p) = heappop(B)\\n lengths.append(l)\\n paths.append(p)\\n else:\\n break\\n\\n return (lengths, paths)\",\n \"def search_shortest_paths(\\n self,\\n src_nodes: list[TN],\\n dst_node: TN,\\n operation_src: str,\\n operation_dest: str,\\n domain: str,\\n limit_dest_schemes: list[str],\\n *,\\n session: \\\"Session\\\",\\n ) -> dict[TN, list[dict[str, Any]]]:\\n\\n for rse in itertools.chain(src_nodes, [dst_node], self._multihop_nodes):\\n rse.ensure_loaded(load_attributes=True, load_info=True, session=session)\\n self.ensure_edges_loaded(session=session)\\n\\n if self._multihop_nodes:\\n # Filter out island source RSEs\\n nodes_to_find = {node for node in src_nodes if node.out_edges}\\n else:\\n nodes_to_find = set(src_nodes)\\n\\n class _NodeStateProvider:\\n _hop_penalty = self._hop_penalty\\n\\n def __init__(self, node: TN):\\n self.enabled: bool = True\\n self.cost: _Number = 0\\n if node != dst_node:\\n try:\\n self.cost = int(node.attributes.get('hop_penalty', self._hop_penalty))\\n except ValueError:\\n self.cost = self._hop_penalty\\n\\n scheme_missmatch_found = {}\\n\\n class _EdgeStateProvider:\\n def __init__(self, edge: TE):\\n self.edge = edge\\n self.chosen_scheme = {}\\n\\n @property\\n def cost(self) -> _Number:\\n return self.edge.cost\\n\\n @property\\n def enabled(self) -> bool:\\n try:\\n matching_scheme = rsemgr.find_matching_scheme(\\n rse_settings_src=self.edge.src_node.info,\\n rse_settings_dest=self.edge.dst_node.info,\\n operation_src=operation_src,\\n operation_dest=operation_dest,\\n domain=domain,\\n scheme=limit_dest_schemes if self.edge.dst_node == dst_node and limit_dest_schemes else None,\\n )\\n self.chosen_scheme = {\\n 'source_scheme': matching_scheme[1],\\n 'dest_scheme': matching_scheme[0],\\n 'source_scheme_priority': matching_scheme[3],\\n 'dest_scheme_priority': matching_scheme[2],\\n }\\n return True\\n except RSEProtocolNotSupported:\\n scheme_missmatch_found[self.edge.src_node] = True\\n return False\\n\\n paths = {dst_node: []}\\n for node, distance, _, edge_to_next_hop, edge_state in self.dijkstra_spf(dst_node=dst_node,\\n nodes_to_find=nodes_to_find,\\n node_state_provider=_NodeStateProvider,\\n edge_state_provider=_EdgeStateProvider):\\n nh_node = edge_to_next_hop.dst_node\\n edge_state = cast(_EdgeStateProvider, edge_state)\\n hop = {\\n 'source_rse': node,\\n 'dest_rse': nh_node,\\n 'hop_distance': edge_state.cost,\\n 'cumulated_distance': distance,\\n **edge_state.chosen_scheme,\\n }\\n paths[node] = [hop] + paths[nh_node]\\n\\n nodes_to_find.discard(node)\\n if not nodes_to_find:\\n # We found the shortest paths to all desired nodes\\n break\\n\\n result = {}\\n for node in src_nodes:\\n path = paths.get(node)\\n if path is not None:\\n result[node] = path\\n elif scheme_missmatch_found.get(node):\\n result[node] = []\\n return result\",\n \"def _dfs(\\n self, kg: KG, entity: Vertex, is_reverse: bool = False\\n ) -> List[Walk]:\\n self.sampler.visited = set()\\n walks: List[Walk] = []\\n assert self.max_walks is not None\\n\\n rng = np.random.RandomState(self.random_state)\\n\\n while len(walks) < self.max_walks:\\n sub_walk: Walk = (entity,)\\n d = 1\\n while d // 2 < self.max_depth:\\n pred_obj = self.sampler.sample_hop(\\n kg, sub_walk, d // 2 == self.max_depth - 1, is_reverse\\n )\\n if pred_obj is None:\\n break\\n\\n if is_reverse:\\n if (\\n pred_obj[0] in self.communities\\n and rng.random() < self.hop_prob\\n ):\\n community_nodes = self.labels_per_community[\\n self.communities[pred_obj[0]]\\n ]\\n sub_walk = (\\n pred_obj[1],\\n rng.choice(community_nodes),\\n ) + sub_walk\\n else:\\n sub_walk = (pred_obj[1], pred_obj[0]) + sub_walk\\n else:\\n if (\\n pred_obj[1] in self.communities\\n and rng.random() < self.hop_prob\\n ):\\n community_nodes = self.labels_per_community[\\n self.communities[pred_obj[1]]\\n ]\\n sub_walk += (\\n pred_obj[0],\\n rng.choice(community_nodes),\\n )\\n else:\\n sub_walk += (pred_obj[0], pred_obj[1])\\n d = len(sub_walk) - 1\\n walks.append(sub_walk)\\n return list(walks)\",\n \"def test_heuristic_first_steps(self):\\n graph = {n: set(self.deterministic_graph[n]) - set([n])\\n for n in self.deterministic_graph}\\n print(\\\"Graph {}:\\\".format(graph))\\n elim_node = min_fill_in_heuristic(graph)\\n steps = []\\n\\n while elim_node is not None:\\n print(\\\"Removing {}:\\\".format(elim_node))\\n steps.append(elim_node)\\n nbrs = graph[elim_node]\\n\\n for u, v in itertools.permutations(nbrs, 2):\\n if v not in graph[u]:\\n graph[u].add(v)\\n\\n for u in graph:\\n if elim_node in graph[u]:\\n graph[u].remove(elim_node)\\n\\n del graph[elim_node]\\n print(\\\"Graph {}:\\\".format(graph))\\n elim_node = min_fill_in_heuristic(graph)\\n\\n # check only the first 2 elements for equality\\n assert_equals(steps[:2], [6, 5])\",\n \"def get_all_pairs(G):\\n # list all (start,dest) pairs between which the route must be computed\\n pairs_list = [(start, dest) for dest in G.nodes for start in G.nodes]\\n\\n # shuffle all elements in-place\\n random.shuffle(pairs_list)\\n\\n # generate a set from the list\\n pairs_set = set(pairs_list)\\n\\n return pairs_list, pairs_set\",\n \"def multipleTravellingSalesmen2(self, iterations=None):\\n if not iterations:\\n iterations = self.mTSPIterations\\n\\n paths, self.totaldistanceMTSP = self.greedyMultiplePaths(self.ships)\\n\\n # Run single travelling salesman on each of the ships\\n paths = [self.singleTravellingSalesman2(path, iterations=5000) for path in paths]\\n\\n # IF TWO OR MORE SHIPS!!!\\n # Point exchange between ships and rerun tsp on each ship\\n if len(self.ships) > 1:\\n for _ in range(iterations):\\n twopathindices = random.sample(xrange(len(paths)), 2)\\n if min([len(path) for path in paths]) > 1:\\n newtwopaths = self.swapTwoPointsBetweenPaths([paths[index] for index in twopathindices])\\n newtwopaths = [self.singleTravellingSalesman2(path, iterations=100) for path in newtwopaths]\\n if self.totalPathDistance(newtwopaths) < self.totalPathDistance([paths[index] for index in twopathindices]):\\n for i, index in enumerate(twopathindices):\\n paths[index] = newtwopaths[i]\\n\\n return [path[::-1] for path in paths]\\n\\n # Might be a simple tsp whereby the new points search for the twp closest points and\\n # inserts between them on the path\",\n \"def shiftFlows(self, targetFlows, stepSize):\\n for l in self.link:\\n current = self.link[l].flow\\n target = targetFlows[l]\\n new = current *(1 - stepSize)+target*stepSize\\n self.link[l].flow = new\\n self.link[l].updateCost()\",\n \"def max_flow(self, source, sink):\\n\\n path = self.valid_path(source, sink, [])\\n\\n while path:\\n # get the maximum possible flow that can be taken from this path:\\n max_flow = min([edge.capacity for edge in path])\\n for edge in path:\\n self.edges[edge] += max_flow\\n path = self.valid_path(source, sink, [])\\n\\n # Compute all the flows from the neighbors of source:\\n return sum([self.edges[edge] for edge in self.adjacents[source]])\",\n \"def generate_pairs(self, all_walks):\\n logging.info(['edge_types before generate pairs', self.edge_types])\\n\\n pairs = []\\n skip_window = self.config['win_size'] // 2\\n for layer_id, e_type in enumerate(self.edge_types):\\n walks = all_walks[e_type]\\n for walk in tqdm.tqdm(walks):\\n for i in range(len(walk)):\\n for j in range(1, skip_window + 1):\\n if i - j >= 0 and walk[i] != walk[i - j]:\\n neg_nodes = self.graph[e_type].sample_nodes(\\n self.config['neg_num'])\\n pairs.append(\\n (walk[i], walk[i - j], *neg_nodes, layer_id))\\n if i + j < len(walk) and walk[i] != walk[i + j]:\\n neg_nodes = self.graph[e_type].sample_nodes(\\n self.config['neg_num'])\\n pairs.append(\\n (walk[i], walk[i + j], *neg_nodes, layer_id))\\n return pairs\",\n \"def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\\n demand: float,\\n routing: np.ndarray) -> np.ndarray:\\n edge_mapping = {edge: i for i, edge in\\n enumerate(sorted(self.graph.edges))}\\n\\n link_utilisation = np.zeros(self.num_edges)\\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\\n node_flow[flow[0]] = demand\\n\\n to_explore = [flow[0]]\\n while to_explore:\\n current_node = to_explore.pop(0)\\n current_flow = node_flow[current_node]\\n\\n # this is the flow destination node so we absorb all flow\\n if current_node == flow[1]:\\n node_flow[current_node] = 0.0\\n continue\\n\\n # push the flow at this node over all edges\\n for edge in self.graph.out_edges(current_node):\\n edge_index = edge_mapping[edge]\\n ratio = routing[edge_index]\\n flow_to_send = ratio * current_flow\\n # only send flow if greater than epsilon (so no 'infinite' loops)\\n if flow_to_send > 1.e-8:\\n node_flow[edge[1]] += ratio * current_flow\\n # all important step, update our output\\n link_utilisation[edge_index] += ratio * current_flow\\n # have updated the dst so add it to the list of things to do\\n to_explore.append(edge[1])\\n # we've moved all the flow from this node now, so reset back to zero\\n node_flow[current_node] = 0.0\\n\\n return link_utilisation\",\n \"def tsp_annealing_random(T, scheme, route, adjacency_matrix, max_chain_length,c):\\n best = route.copy()\\n chains = 0\\n cost_list = []\\n T_0 = T\\n T_list = []\\n \\n while T > 0:\\n # Sample city from route\\n temp = route.copy()\\n index1, index2 = np.random.randint(1,len(best)-1,size=2)\\n\\n sd, cost0 = calculate_cost(route,adjacency_matrix)\\n cost_list.append(cost0)\\n\\n temp[index1:index2] = temp[index2-1:index1-1:-1]\\n _, cost1 = calculate_cost(temp,adjacency_matrix)\\n\\n chains += 1\\n T_list.append(T)\\n\\n # Adjust temperature\\n if scheme == \\\"exp\\\":\\n T = T*c\\n if scheme == \\\"log\\\":\\n alpha = 50\\n T = T_0/(1+alpha*np.log(1+chains))\\n if scheme == \\\"std\\\":\\n delta = .1\\n T = T / (1 + ((np.log(1+delta)* T) / (3 * sd)))\\n if scheme == \\\"quad\\\":\\n alpha = 1\\n T = T_0/(1+alpha*chains**2)\\n\\n # Metropolis step \\n if cost0 > cost1:\\n route = temp.copy()\\n else:\\n U = rs.uniform()\\n if U < np.exp((cost0-cost1)/T):\\n route = temp.copy()\\n\\n best = route.copy()\\n if chains > max_chain_length:\\n return best, cost_list\\n return best, cost_list\",\n \"def objective(graph, flows):\\n\\n G = graph.copy()\\n rules = {}\\n flows.sort(key=lambda a: a[1], reverse=True)\\n\\n for flow,demand in flows:\\n src = get_host_from_ip(G, flow.nw_src)\\n dst = get_host_from_ip(G, flow.nw_dst)\\n\\n if not (src and dst):\\n continue\\n if not (src in G.nodes() and dst in G.nodes()):\\n continue\\n\\n path = widest_path(G, src, dst)\\n\\n hops = []\\n for a,b in pairwise(path):\\n hops.append(Hop(dpid=int(a[1:]), port=G.edge[a][b]['port']))\\n G.edge[a][b]['capacity'] -= demand\\n G.edge[b][a]['capacity'] -= demand\\n\\n rules[flow] = hops\\n\\n return rules\",\n \"def getShortestPath(self, src, dest):\\n vertices = self.floorGraph.getVertList()\\n unvisitedQueue = []\\n srcPath = Path()\\n srcPath.addNode(src)\\n srcPath.pathValue = 0\\n unvisitedQueue.append(srcPath)\\n connections = self.floorGraph.getVertex(src).getConnections()\\n #initialisez distances\\n for vertex in vertices:\\n newPath = Path()\\n newPath.nodeList = list(srcPath.nodeList)\\n newPath.addNode(vertex)\\n if self.floorGraph.getVertex(vertex) in connections:\\n newPath.pathValue = self.floorGraph.getVertex(src).getWeight(self.floorGraph.getVertex(vertex))\\n unvisitedQueue.append(newPath)\\n else:\\n newPath.pathValue = math.inf\\n self.shortestDistanceMap[src+vertex] = newPath\\n # updates distances as per shorter routes\\n while len(unvisitedQueue) is not 0:\\n unvisitedQueue = sorted(unvisitedQueue, key=functools.cmp_to_key(compareNodes))\\n chkPath = unvisitedQueue.pop(0)\\n chkNode = chkPath.nodeList[len(chkPath.nodeList)-1]\\n for vertex in vertices:\\n if(self.floorGraph.getVertex(vertex) in self.floorGraph.getVertex(chkNode).getConnections()):\\n newWeight = chkPath.pathValue + self.floorGraph.getVertex(chkNode).getWeight(self.floorGraph.getVertex(vertex))\\n if(newWeight < self.shortestDistanceMap[src+vertex].pathValue):\\n self.shortestDistanceMap[src+vertex].pathValue = newWeight\\n self.shortestDistanceMap[src+vertex].nodeList = list(chkPath.nodeList)\\n self.shortestDistanceMap[src+vertex].nodeList.append(vertex)\\n newPath = Path()\\n newPath.nodeList = list(self.shortestDistanceMap[src+vertex].nodeList)\\n newPath.pathValue = newWeight\\n unvisitedQueue.append(newPath)\\n print(self.shortestDistanceMap[src+dest].nodeList)\\n print(self.shortestDistanceMap[src+dest].pathValue)\",\n \"def shuffle(self) -> NoReturn:\\n for edge_type in self.edge_types:\\n for edge_class in range(self.edge_types[edge_type]):\\n self.train_edges[edge_type][edge_class] = np.random.permutation(\\n self.train_edges[edge_type][edge_class])\\n\\n self.freebatch_edge_types = {edge_type: list(range(edge_class))\\n for edge_type, edge_class in self.edge_types.items()}\\n self.batch_num = {edge_type: [0] * edge_class for edge_type, edge_class in\\n self.edge_types.items()}\\n self.took_all_edges = {edge_type: False for edge_type in self.edge_types}\\n self.iter = 0\",\n \"def __generate_connecticity_increasing_canidates(self,k=3):\\n result = set()\\n \\n if k < 3:\\n k = 3\\n \\n self.__logger.info(\\\"IMPROOVE_NETWORK: Try to seek {} nodes which are currently bad connected\\\".format(k))\\n candidates = heapq.nlargest(3*k, self.__generate_all_shortest_paths(), key=itemgetter(0))\\n\\n for _, path in candidates:\\n result.add(path[0])\\n result.add(path[-1])\\n\\n self.__logger.info(\\\"IMPROOVE_NETWORK: Found {} candidates which are currently bad connected\\\".format(len(result))) \\n if len(result) <= k:\\n return list(result)\\n self.__logger.info(\\\"IMPROOVE_NETWORK: Sample {} items from the candidates as was requested\\\".format(k))\\n tmp = list(result)\\n random.shuffle(tmp)\\n return tmp[0:k]\",\n \"def get_weight_from_minflow(self):\\n start_nodes = []\\n end_nodes = []\\n capacities = []\\n unit_costs = []\\n A = 0\\n s_prime = self.sink() + 1\\n t_prime = self.sink() + 2\\n x = self.sink() + 3\\n # for every edge in the graph, add edge to mincost flow instance with\\n # infinite capacity and cost 1\\n # also add backwards edge\\n for arc in self.arc_info.keys():\\n # forward edge\\n start_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"start\\\"],\\n self.arc_info[arc][\\\"destin\\\"]))\\n # backward edge\\n start_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n capacities.append(int(self.arc_info[arc][\\\"weight\\\"])) # no negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"destin\\\"],\\n self.arc_info[arc][\\\"start\\\"]))\\n # add (x,s) and (t,x) edges with same cap, cost as above\\n in_weight_x = 0\\n for in_arc in self.in_arcs_lists[self.sink()]:\\n in_weight_x += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight_x = 0\\n for out_arc in self.out_arcs_lists[self.source()]:\\n out_weight_x += self.arc_info[out_arc][\\\"weight\\\"]\\n # (x,s)\\n start_nodes.append(x)\\n end_nodes.append(self.source())\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.source()))\\n # backward\\n start_nodes.append(self.source())\\n end_nodes.append(x)\\n capacities.append(int(out_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.source(),\\n x))\\n # (t,x)\\n start_nodes.append(self.sink())\\n end_nodes.append(x)\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.sink(),\\n x))\\n # backward\\n start_nodes.append(x)\\n end_nodes.append(self.sink())\\n capacities.append(int(in_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.sink()))\\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\\n # and cost 0.\\n for v in self:\\n # process internal verts only, since we assume source and sink have\\n # no in and out edges respectively\\n if v != self.source() and v != self.sink():\\n # compute a-exc(v)\\n in_weight = 0\\n for in_arc in self.in_arcs_lists[v]:\\n in_weight += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight = 0\\n for out_arc in self.out_arcs_lists[v]:\\n out_weight += self.arc_info[out_arc][\\\"weight\\\"]\\n a_exc = out_weight - in_weight\\n if a_exc < 0:\\n # add edge (s', v)\\n start_nodes.append(s_prime)\\n end_nodes.append(v)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n v,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (v, t')\\n start_nodes.append(v)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n v,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # process x node\\n a_exc = out_weight_x - in_weight_x\\n if a_exc < 0:\\n # add edge (s', x)\\n start_nodes.append(s_prime)\\n end_nodes.append(x)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n x,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (x, t')\\n start_nodes.append(x)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n x,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # we must send flow of A from s_prime to t_prime\\n supplies = [0]*(len(self) + 3)\\n supplies[s_prime] = int(A)\\n supplies[t_prime] = int(-A)\\n # Instantiate a SimpleMinCostFlow solver.\\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\\n # Add each arc.\\n for i in range(len(start_nodes)):\\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\\n end_nodes[i], capacities[i], unit_costs[i])\\n # Add node supplies\\n for i in range(0, len(supplies)):\\n min_cost_flow.SetNodeSupply(i, supplies[i])\\n # Find the minimum cost flow between node s' and t'.\\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\\n print('Minimum cost:', min_cost_flow.OptimalCost())\\n print('')\\n print(' Arc Flow / Capacity Cost')\\n for i in range(min_cost_flow.NumArcs()):\\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\\n print('%1s -> %1s %3s / %3s %3s' % (\\n min_cost_flow.Tail(i),\\n min_cost_flow.Head(i),\\n min_cost_flow.Flow(i),\\n min_cost_flow.Capacity(i),\\n cost))\\n # update arcs\\n start = min_cost_flow.Tail(i)\\n destin = min_cost_flow.Head(i)\\n if start != s_prime and \\\\\\n start != t_prime and \\\\\\n start != x and \\\\\\n destin != s_prime and \\\\\\n destin != t_prime and \\\\\\n destin != x:\\n # if forward, increase flow. otherwise decrease.\\n print(\\\"Processing edge ({}, {})\\\".format(start, destin))\\n if start < destin:\\n sup_flow = min_cost_flow.Flow(i)\\n else:\\n sup_flow = -min_cost_flow.Flow(i)\\n temp_start = start\\n start = destin\\n destin = temp_start\\n print(\\\"Has become ({}, {}) with sup {}\\\".format(start,\\n destin,\\n sup_flow))\\n arc = self.get_arc(start, destin)\\n if (sup_flow != 0) or (\\\"lower_bound\\\" not in \\\\\\n self.arc_info[arc].keys()):\\n print(\\\"We should add this\\\")\\n old_flow = self.arc_info[arc][\\\"weight\\\"]\\n new_flow = old_flow + sup_flow\\n self.arc_info[arc][\\\"weight\\\"] = int(new_flow)\\n print(\\\"Edge ({},{}) weight is changed from {} to {}\\\".format(\\n start,\\n destin,\\n old_flow,\\n new_flow))\\n else:\\n print('There was an issue with the min cost flow input.')\\n #self.check_conservation_of_flow() # check that solution is valid\",\n \"def __generate_random_nodes(self,k=3):\\n if k < 3:\\n k = 3\\n\\n k = min(k,len(self.G.nodes()))\\n self.__logger.info(\\\"RANDOM_NODES: try to generate a set of {} nodes sampled with uniform distribution\\\".format(k))\\n \\n return random.sample(self.G.nodes(),k)\",\n \"def find_unique_paths(self, source: str, target: str, number: int = 3) -> List[Tuple[List[str], float]]:\\n assert self.graph_handler\\n counter = 0\\n path_tuple_list = list()\\n # # # Initialise iterator over shortest simple paths if it is either not set or source/target do not match\\n if not self._use_old_iterator or \\\\\\n self._unique_iterator_memory is None or \\\\\\n self._unique_iterator_memory[0][0][0] != source or \\\\\\n self._unique_iterator_memory[0][0][-1] != target:\\n path_iterator = iter(nx.shortest_simple_paths(self.graph_handler.graph, source, target, weight=\\\"weight\\\"))\\n # # # Find first path and its cost\\n old_path = next(path_iterator)\\n old_path_cost = nx.path_weight(self.graph_handler.graph, old_path, weight=\\\"weight\\\")\\n else:\\n path_iterator = self._unique_iterator_memory[1]\\n old_path = self._unique_iterator_memory[0][0]\\n old_path_cost = self._unique_iterator_memory[0][1]\\n\\n while counter < number:\\n same_cost = True\\n tmp_path_list: List[List[str]] = list()\\n # # # Collect all paths with same cost\\n # TODO: Parameter for max tmp paths\\n n_max_collected_paths = 10\\n while same_cost and len(tmp_path_list) < n_max_collected_paths:\\n # # # Append old path to tmp_path list\\n tmp_path_list.append(old_path)\\n # # # Get next path and its cost\\n new_path = next(path_iterator, None)\\n # # # Break loop if no path is returned\\n if new_path is None:\\n break\\n new_path_cost = nx.path_weight(self.graph_handler.graph, new_path, weight=\\\"weight\\\")\\n # # # Check if new cost different to old cost\\n if abs(old_path_cost - new_path_cost) > 1e-12:\\n same_cost = False\\n # # # Overwrite old path with new path\\n old_path = new_path\\n\\n # # # Append path with most nodes to tuple list and its cost\\n path_tuple_list.append((max(tmp_path_list, key=lambda x: len(x)), # pylint: disable=unnecessary-lambda\\n old_path_cost))\\n # # # Break counter loop if no more paths to target are found\\n if new_path is None:\\n break\\n old_path_cost = new_path_cost\\n counter += 1\\n # # # Store iterator and path info (list of nodes and length)\\n if new_path is not None:\\n self._unique_iterator_memory = ((new_path, new_path_cost), path_iterator)\\n return path_tuple_list\",\n \"def __dynamicThroughput( self, sourceSEs, destSEs ):\\n res = self.__getTimeToStart()\\n if not res['OK']:\\n gLogger.error( res['Message'] )\\n return {}\\n channelInfo = res['Value']\\n\\n timeToSite = {} # Maintains time to site including previous hops\\n siteAncestor = {} # Maintains the ancestor channel for a site\\n tree = {} # Maintains replication tree\\n while len( destSEs ) > 0:\\n minTotalTimeToStart = float( \\\"inf\\\" )\\n candidateChannels = []\\n sourceActiveSEs = self.__getActiveSEs( sourceSEs )\\n for destSE in destSEs:\\n destSites = self.__getChannelSitesForSE( destSE )\\n localTransfer = False\\n for destSite in destSites:\\n if localTransfer: break\\n for sourceSE in sourceActiveSEs:\\n if localTransfer: break\\n sourceSites = self.__getChannelSitesForSE( sourceSE )\\n for sourceSite in sourceSites:\\n if localTransfer: break\\n channelName = '%s-%s' % ( sourceSite, destSite )\\n if channelInfo.has_key( channelName ):\\n channelID = channelInfo[channelName]['ChannelID']\\n if tree.has_key( channelID ):\\n continue\\n channelTimeToStart = channelInfo[channelName]['TimeToStart']\\n if timeToSite.has_key( sourceSE ):\\n totalTimeToStart = timeToSite[sourceSE] + channelTimeToStart + self.sigma\\n else:\\n totalTimeToStart = channelTimeToStart\\n #print '%s-%s %s %s' % (sourceSE,destSE,channelTimeToStart,totalTimeToStart)\\n localTransfer = ( sourceSite == destSite )\\n if localTransfer or totalTimeToStart < minTotalTimeToStart:\\n minTotalTimeToStart = totalTimeToStart\\n selectedPathTimeToStart = totalTimeToStart\\n candidateChannels = [( sourceSE, destSE, channelID )]\\n elif totalTimeToStart == minTotalTimeToStart:\\n candidateChannels.append( ( sourceSE, destSE, channelID ) )\\n\\n #minTotalTimeToStart = totalTimeToStart\\n #selectedPathTimeToStart = totalTimeToStart\\n #selectedSourceSE = sourceSE\\n #selectedDestSE = destSE\\n #selectedChannelID = channelID\\n else:\\n errStr = 'StrategyHandler.__dynamicThroughput: Channel not defined'\\n gLogger.warn( errStr, channelName )\\n\\n #print 'Selected %s \\\\n' % selectedPathTimeToStart\\n\\n random.shuffle( candidateChannels )\\n selectedSourceSE, selectedDestSE, selectedChannelID = candidateChannels[0]\\n timeToSite[selectedDestSE] = selectedPathTimeToStart\\n siteAncestor[selectedDestSE] = selectedChannelID\\n\\n if siteAncestor.has_key( selectedSourceSE ):\\n waitingChannel = siteAncestor[selectedSourceSE]\\n else:\\n waitingChannel = False\\n tree[selectedChannelID] = {}\\n tree[selectedChannelID]['Ancestor'] = waitingChannel\\n tree[selectedChannelID]['SourceSE'] = selectedSourceSE\\n tree[selectedChannelID]['DestSE'] = selectedDestSE\\n tree[selectedChannelID]['Strategy'] = 'DynamicThroughput'\\n sourceSEs.append( selectedDestSE )\\n destSEs.remove( selectedDestSE )\\n return tree\",\n \"def run_destination_reduction(self):\\n s = self.sources\\n t = self.destinations\\n\\n # get the union set of source edges\\n s_edges = [self.out_edges(x) for x in s]\\n s_edges_idx = [set(self.get_edges_indices(src)) for src in s_edges]\\n S = set.union(*s_edges_idx)\\n\\n # now starting from the sources\\n T_curr = [set(self.in_edges(x)) for x in t]\\n T_curr_idx = [set(self.get_edges_indices(x)) for x in T_curr]\\n T_union = set.union(*[set(x) for x in T_curr])\\n T_union_idx = set.union(*T_curr_idx)\\n self.dst_evolution_rec = [T_curr_idx]\\n\\n while not T_union_idx.issubset(S):\\n # get the edges out of the max-ordered node\\n tail_nodes = set([x[0] for x in T_union])\\n tail_nodes = tail_nodes - set(s)\\n v = max(tail_nodes, key=lambda p: self.node[p]['index'])\\n\\n E = set([edge for edge in T_union if edge[0] == v])\\n E_curr = [x.intersection(E) for x in T_curr]\\n\\n T_next = []\\n Uv = self.in_edges(v)\\n for (Ex, Tx) in zip(E_curr, T_curr):\\n if Ex:\\n T_next.append((Tx - Ex).union(Uv))\\n else:\\n T_next.append(Tx)\\n\\n T_curr = T_next\\n T_curr_idx = [set(self.get_edges_indices(x)) for x in T_curr]\\n self.dst_evolution_rec.append(T_curr_idx)\\n\\n T_union = set.union(*[set(x) for x in T_curr])\\n T_union_idx = set.union(*T_curr_idx)\",\n \"def configuration_model(g, kmin, kmax, size, c, offset):\\n # Makes sure that networks have an even number of half-edges, since\\n # the number of half-edges prepared for linking can be uneven.\\n its = inverse_transform_sampling(g, kmin, kmax, size, offset)\\n sum_its = sum(its)\\n while sum_its % 2 != c % 2:\\n its = inverse_transform_sampling(g, kmin, kmax, size, offset)\\n sum_its = sum(its)\\n\\n # Brings the dist. seq. into the half-edge form,\\n # e.g. [1,2,3] -> [0,1,1,2,2,2]\\n seq = []\\n k = 0\\n for i in range(size):\\n for j in range(k, k + its[i]):\\n seq += [i]\\n k += 1\\n\\n # Edges that link to other modules\\n c_node = np.random.choice(seq, size=c, replace=False)\\n for i in range(c):\\n seq.remove(c_node[i])\\n \\n # Connects the half-edges randomly among each other\\n np.random.shuffle(seq)\\n links = np.sort(np.reshape(seq, (int(len(seq)/2), 2)))\\n links = links.tolist()\\n \\n # Separates the unique and the multi/self links.\\n # The list links is left with multi and self links.\\n links_unique = []\\n k = 0\\n while k < len(links):\\n if links[k][0] != links[k][1] and links[k] not in links_unique:\\n links_unique.append(links.pop(k))\\n else:\\n k += 1\\n \\n # Rewires the multi/self links\\n for multi in links:\\n r1 = random.randint(0, len(links_unique)-1)\\n r2 = random.randint(0, 1)\\n r3 = random.randint(0, 1)\\n links_unique[r1][r2], multi[r3] = multi[r3], links_unique[r1][r2]\\n \\n network = gt.Graph(directed=False)\\n network.add_edge_list(links_unique)\\n network.add_edge_list(links)\\n\\n gt.stats.remove_parallel_edges(network)\\n gt.stats.remove_self_loops(network)\\n \\n return network, c_node\",\n \"def gen_task_sets_fairgen(nsets):\\n start = time()\\n eval_task_sets = []\\n for util in utils:\\n task_sets = []\\n for i in range(nsets):\\n ts = synth.mc_fairgen(set_id=i, u_lo=util, implicit_deadlines=True)\\n synth.synth_c_pmf(ts)\\n synth.set_fixed_priorities(ts)\\n task_sets.append(ts)\\n eval_task_sets.append(task_sets)\\n stop = time()\\n print('Task Set Generation MC-Fairgen: %.3fs' % (stop - start))\\n pickle.dump(eval_task_sets, open(task_sets_path + 'task_sets_fairgen', 'wb'))\",\n \"def optimal_route(graph,homes,source):\\n number_of_homes = len(homes)\\n all_pairs_distances = dict(nx.shortest_path_length(graph, weight = 'weight'))\\n all_pairs_shortest_paths = dict(nx.shortest_path(graph, weight = 'weight'))\\n homes_subgraph = tsp_routines.complete_shortest_path_subgraph_efficient(graph,homes,all_pairs_distances)\\n num_clusters_to_clustering = clustering_routines.all_k_clusters(homes_subgraph,number_of_homes)\\n \\n cluster_list = range(1,number_of_homes+1)\\n optimal_cost = np.Inf\\n optimal_dropoffs = dict()\\n optimal_route = []\\n optimal_num_clusters = 0\\n\\n\\n for num_clusters in cluster_list:\\n home_clusters = num_clusters_to_clustering[num_clusters]\\n cost, dropoffs, route = solver(graph,homes,source,home_clusters,all_pairs_distances,all_pairs_shortest_paths)\\n if cost < optimal_cost:\\n optimal_cost = cost\\n optimal_route = route \\n optimal_dropoffs = dropoffs\\n optimal_num_clusters = num_clusters\\n\\n return optimal_cost, optimal_dropoffs, optimal_route, optimal_num_clusters\",\n \"def simulate_graph(seed, cluster_sizes, del_factor, ins_factor):\\n rand.seed(seed)\\n cluster_boundaries = np.cumsum(cluster_sizes)\\n print(\\\"#seed:\\\", seed)\\n print(\\\"#deletion factor:\\\", del_factor)\\n print(\\\"#insertion factor:\\\", ins_factor)\\n optimal_costs = np.array([0])\\n for c in range(0, len(cluster_sizes)-1):\\n n_c = cluster_sizes[c+1]\\n offset_c = cluster_boundaries[c]\\n edges_c = generate_edges(n_c, offset_c)\\n disturb_cluster(n_c, offset_c, edges_c, del_factor, optimal_costs)\\n additional_edges(cluster_boundaries, ins_factor, optimal_costs)\\n print(\\\"#optimal costs:\\\", optimal_costs)\",\n \"def _measure(d, sources, target, niter=25, bound=None):\\n uniques = {}\\n for source in sources:\\n others = list(sources)\\n others.remove(source)\\n others = list(flatten(others))\\n uniques[source] = one_way_skar(d, source, target, others)\\n return uniques\",\n \"def update_flow(self):\\n N = len(self.vertices)\\n _vertices = self.vertices+['_source', '_sink']\\n s, t = _vertices.index('_source'), _vertices.index('_sink')\\n cost, capacity = dok_matrix((N+2, N+2)), dok_matrix((N+2, N+2))\\n\\n cost[:N, :N] = self.cost\\n capacity[:N, :N] = self.upper_bound-self.lower_bound\\n # _source to main vertices\\n l_in = self.lower_bound.toarray().sum(axis=0)\\n us, = l_in.nonzero()\\n for u in us:\\n capacity[s, u] = l_in[u]\\n # main vertices to _sink\\n l_out = self.lower_bound.toarray().sum(axis=1)\\n us, = l_out.nonzero()\\n for u in us:\\n capacity[u, t] = l_out[u]\\n # sink to source\\n infinite_flow = self.upper_bound.toarray().sum()\\n capacity[_vertices.index('sink'), _vertices.index('source')] = infinite_flow\\n\\n # get a feasible flow on original graph by finding the max flow on\\n # auxiliary graph\\n aux_fg = FlowGraph(_vertices, cost, capacity, True)\\n aux_fg.FordFulkerson()\\n assert aux_fg.residual[s].toarray().sum()==0, 'feasible flow within bounds not found'\\n\\n self.residual = aux_fg.residual[:N, :N]\\n s, t = self.vertices.index('source'), self.vertices.index('sink')\\n self.residual[s, t] = 0\\n self.residual[t, s] = 0\\n\\n self.FordFulkerson()\",\n \"def choose_paths_without_simulation(FT, output_dir, iteration, pathset_paths_df, pathset_links_df, veh_trips_df):\\n simulation_iteration = 0\\n ######################################################################################################\\n FastTripsLogger.info(\\\" Step 1. Find out board/alight times for all pathset links from vehicle times\\\")\\n\\n # could do this just to chosen path links but let's do this to the whole pathset\\n pathset_links_df = Assignment.find_passenger_vehicle_times(pathset_links_df, veh_trips_df)\\n\\n # instead of flag_missed_transfers(), set these to pathfinding results\\n pathset_links_df[Assignment.SIM_COL_PAX_ALIGHT_DELAY_MIN] = 0\\n pathset_links_df[Assignment.SIM_COL_PAX_A_TIME ] = pathset_links_df[Passenger.PF_COL_PAX_A_TIME]\\n pathset_links_df[Assignment.SIM_COL_PAX_B_TIME ] = pathset_links_df[Passenger.PF_COL_PAX_B_TIME]\\n pathset_links_df[Assignment.SIM_COL_PAX_LINK_TIME ] = pathset_links_df[Passenger.PF_COL_LINK_TIME]\\n pathset_links_df[Assignment.SIM_COL_PAX_WAIT_TIME ] = pathset_links_df[Passenger.PF_COL_WAIT_TIME]\\n pathset_links_df[Assignment.SIM_COL_PAX_MISSED_XFER ] = 0\\n\\n ######################################################################################################\\n FastTripsLogger.info(\\\" Step 2. Calculate costs and probabilities for all pathset paths\\\")\\n (pathset_paths_df, pathset_links_df) = PathSet.calculate_cost(\\n iteration, simulation_iteration, Assignment.STOCH_DISPERSION,\\n pathset_paths_df, pathset_links_df, FT.passengers.trip_list_df,\\n FT.transfers.transfers_df, FT.tazs.walk_df, FT.tazs.drive_df, veh_trips_df, FT.stops)\\n\\n ######################################################################################################\\n FastTripsLogger.info(\\\" Step 3. Choose a path for each passenger from their pathset\\\")\\n\\n # Choose path for each passenger -- pathset_paths_df and pathset_links_df will now have\\n # SIM_COL_PAX_CHOSEN >=0 for chosen paths/path links\\n (num_passengers_arrived, num_chosen, pathset_paths_df, pathset_links_df) = Passenger.choose_paths(\\n True, # choose for everyone\\n iteration, simulation_iteration,\\n pathset_paths_df, pathset_links_df)\\n\\n # Write the pathsets\\n Passenger.write_paths(output_dir, iteration, simulation_iteration, pathset_paths_df, False, Assignment.OUTPUT_PATHSET_PER_SIM_ITER)\\n Passenger.write_paths(output_dir, iteration, simulation_iteration, pathset_links_df, True, Assignment.OUTPUT_PATHSET_PER_SIM_ITER)\\n\\n # write the final chosen paths for this iteration\\n chosen_links_df = Passenger.get_chosen_links(pathset_links_df)\\n chosen_links_df[\\\"iteration\\\"] = iteration\\n Util.write_dataframe(chosen_links_df, \\\"chosen_links_df\\\", os.path.join(output_dir, \\\"chosenpaths_links.csv\\\"), append=(iteration>1))\\n chosen_links_df.drop([\\\"iteration\\\"], axis=1, inplace=True)\\n\\n chosen_paths_df = Passenger.get_chosen_links(pathset_paths_df)\\n chosen_paths_df[\\\"iteration\\\"] = iteration\\n Util.write_dataframe(chosen_paths_df, \\\"chosen_paths_df\\\", os.path.join(output_dir, \\\"chosenpaths_paths.csv\\\"), append=(iteration>1))\\n chosen_paths_df.drop([\\\"iteration\\\"], axis=1, inplace=True)\\n\\n return (num_passengers_arrived, pathset_paths_df, pathset_links_df)\",\n \"def step(nodes, outputs, edges):\\n flowed = []\\n for node_name in nodes.copy():\\n if node_name in flowed:\\n continue\\n if len(nodes[node_name]) == 2:\\n if node_name in flowed:\\n continue\\n node = [int(value) for value in nodes[node_name]]\\n low_value, high_value = min(node), max(node)\\n low_flow, high_flow = edges[node_name] \\n low_dictionary, low_node_name = low_flow\\n high_dictionary, high_node_name = high_flow\\n low_node = low_dictionary.get(low_node_name, tuple())\\n high_node = high_dictionary.get(high_node_name, tuple())\\n low_dictionary[low_node_name] = low_node + (str(low_value),)\\n high_dictionary[high_node_name] = high_node + (str(high_value),)\\n nodes[node_name] = tuple()\\n if low_dictionary is nodes:\\n flowed.append(low_node_name)\\n if high_dictionary is nodes:\\n flowed.append(high_node_name)\\n return nodes, outputs, edges\",\n \"def get_random_depth_sample(n=8, depths=list(range(2,26,2)), num_samples=100):\\n\\n def get_states(start):\\n frontier = [start]\\n frontier_set = {start}\\n explored = set()\\n\\n states = [False for _ in range(len(depths))]\\n while not all(states):\\n node = frontier.pop(0)\\n frontier_set.remove(node)\\n explored.add(node)\\n\\n children = node.get_children()\\n\\n # It's necessary to shuffle children to get a truly random sample; otherwise, the first child (always\\n # produced from the parent by the same action) produced at a certain depth will always be selected,\\n # and children produced by other actions will never be selected\\n shuffle(children)\\n\\n for child in children:\\n if child not in frontier_set and child not in explored:\\n frontier_set.add(child)\\n frontier.append(child)\\n child.path_cost = node.path_cost+1\\n index = depths.index(child.path_cost) if child.path_cost in depths else None\\n if index is not None and not states[index]:\\n states[index] = {'start': start.sequence, 'end': child.sequence}\\n\\n return states\\n\\n depth_sample = [[] for depth in range(len(depths))]\\n\\n for _ in range(num_samples):\\n start = list(range(1,n+2))\\n shuffle(start)\\n start = PuzzleState(start, path_cost=0)\\n\\n states = get_states(start)\\n print('\\\\rSet ' + str(_+1) + ' of ' + str(num_samples) + ' complete', end='', flush=True)\\n list(map(list.append, depth_sample, states))\\n\\n return depth_sample\",\n \"def _measure(d, sources, target, niter=25, bound=None):\\n uniques = {}\\n for source in sources:\\n others = list(sources)\\n others.remove(source)\\n others = list(flatten(others))\\n uniques[source] = one_way_skar(d, target, source, others)\\n return uniques\",\n \"def sinks(self):\\n s = [node for node in self.nodes() if node.isSink()]\\n s.sort(lambda x,y: cmp(x._id, y._id))\\n return s\",\n \"def splitSources(sources: Iterable[FileId], chunkSize: int) -> List[List[FileId]]:\\n if chunkSize <= 0:\\n raise ValueError(f\\\"chunkSize must be positive ({chunkSize})\\\")\\n\\n sentinel = FileId(visit=math.nan, arm=None, spectrograph=None)\\n sources = [sentinel] + sorted(sources, key=lambda x: x.visit) + [sentinel]\\n\\n # Split sources into sequences, each contiguous in terms of visits.\\n contiguousSeqs = []\\n for iscontiguous, group in itertools.groupby(\\n zip(sources[:-1], sources[1:]),\\n key=lambda pair: pair[1].visit - pair[0].visit == 1\\n ):\\n group = list(group)\\n if iscontiguous:\\n contiguousSeqs.append([pair[0] for pair in group] + [group[-1][-1]])\\n else:\\n contiguousSeqs.extend([pair[-1]] for pair in group[:-1])\\n\\n # Further split the contiguous sequences into small chunks\\n chunks = []\\n for seq in contiguousSeqs:\\n n = len(seq)\\n numChunks = (n + chunkSize - 1) // chunkSize\\n quotient = n // numChunks\\n remainder = n % numChunks\\n for i in range(numChunks):\\n if remainder > 0:\\n remainder -= 1\\n numToPop = quotient + 1\\n else:\\n numToPop = quotient\\n chunks.append(seq[:numToPop])\\n seq = seq[numToPop:]\\n assert(len(seq) == 0)\\n\\n return chunks\",\n \"def shortest_route(self, src, dest):\\n\\n # Dijkstra with unusual start condition to prevent src -> src == 0 distance\\n x_in = set()\\n a = defaultdict(lambda: float('inf'))\\n v = self.V.copy()\\n\\n for node, cost in self.G[src].items():\\n a[node] = cost\\n x_in.add(node)\\n v.remove(node)\\n\\n while x_in != self.V:\\n mn = float('inf')\\n new = None\\n for x in x_in:\\n for node, cost in self.G[x].items():\\n if node in v:\\n if (a[x] + cost) < mn: # optimize large/dense G with pri. q\\n mn = a[x] + cost\\n new = (x, node, cost)\\n if new is None:\\n break\\n x, node, cost = new\\n x_in.add(node)\\n v.remove(node)\\n a[node] = a[x] + cost\\n return a[dest]\",\n \"def find_all_cycles(s,graph):\\n\\n grph = u.edge_to_list_dict(graph)\\n node_cnt = len(grph)\\n k = z.Int(\\\"k\\\")\\n syms = [z.Int('node%s'%i) for i in range(node_cnt)]\\n\\n # s.add(syms[0] == 0) # start node is a 0\\n s.add(k < node_cnt)\\n s.add(k > 1)\\n\\n o = z.Optimize()\\n\\n # for source, sinks in sgraph.s_adj_list():\\n for i in range(node_cnt):\\n s.add(syms[i] >= 0)\\n s.add(syms[i] <= k)\\n s.add(z.Or([syms[j] == ((syms[i] + 1) % k) for j in grph[i]]) == (syms[i] == 0))\\n\\n\\n r = []\\n m = []\\n\\n # o.minimize(z.Sum([syms[i] for i in range(node_cnt)]))\\n s.add(z.Product([syms[i] for i in range(node_cnt)]) == 0)\\n done = False\\n while not done:\\n if s.check() == z.sat:\\n m = s.model()\\n r.append(m)\\n s.add(k != m[k])\\n else:\\n done = True\\n\\n return r\",\n \"def sample_paths(S0, N, u, d, q, M):\\n value = S0 * np.ones((M, 1)) # M sample paths at once\\n paths = np.zeros((M, N + 1))\\n paths[:, 0] = value[:, 0]\\n for i in np.arange(1, N + 1, 1): # time steps\\n random_values = bernoulli.rvs(size=(M, 1), p=q)\\n up_moves = random_values * u\\n down_moves = -1 * (random_values - 1) * d\\n value = np.multiply(value, up_moves + down_moves)\\n paths[:, i] = value[:, 0]\\n return paths\",\n \"def choose_k_away(k, node, precomputed=True):\\n if precomputed:\\n sps = np.load('./short_paths/' + str(node) + '.npy')\\n else:\\n sps = shortest_path(node)\\n nodes = []\\n for index, x in enumerate(sps):\\n if x == k and index in poss_targets:\\n nodes.append(index)\\n return nodes\",\n \"def naiveGlobalRouting(self):\\n for e_list in self.s2e.values():\\n for e in e_list:\\n slot_path = []\\n src_slot = self.v2s[e.src]\\n dst_slot = self.v2s[e.dst]\\n slot_path.append(src_slot)\\n\\n curr = src_slot\\n len_x = src_slot.getLenX()\\n len_y = src_slot.getLenY()\\n\\n # first go in X direction\\n x_diff = curr.getPositionX() - dst_slot.getPositionX()\\n if x_diff:\\n dir = 'LEFT' if x_diff > 0 else 'RIGHT'\\n for i in range(int(abs(x_diff/len_x))):\\n curr = self.slot_manager.createSlotForRouting(curr.getNeighborSlotName(dir))\\n slot_path.append(curr)\\n\\n y_diff = curr.getPositionY() - dst_slot.getPositionY()\\n if y_diff:\\n dir = 'DOWN' if y_diff > 0 else 'UP'\\n for i in range(int(abs(y_diff/len_y))):\\n curr = self.slot_manager.createSlotForRouting(curr.getNeighborSlotName(dir))\\n slot_path.append(curr)\\n \\n assert curr == dst_slot\\n \\n slot_path = slot_path[1:-1] # exclude the src and the dst\\n logging.info(f'{e.name}: {self.v2s[e.src].getName()} -> {self.v2s[e.dst].getName()} : ' + ' '.join(s.getName() for s in slot_path))\\n self.e_name2path[e.name] = slot_path\",\n \"def djikstra(nodes,links,source,dest):\\n route = []\\n vertexes = []\\n for v in nodes:\\n v.set_dist(float(\\\"inf\\\"))\\n v.set_prev(None)\\n heappush(vertexes, v)\\n source.set_dist(0)\\n heapify(vertexes)\\n while vertexes:\\n unsorted = False\\n u = heappop(vertexes)\\n if u == dest:\\n break #because we found the destination no need to look further\\n for v in u.get_links():\\n if v.get_enabled():\\n alt = u.get_dist() + 1\\n target = v.get_target()\\n if alt < target.get_dist():\\n target.set_dist(alt)\\n target.set_prev(u)\\n unsorted = True #just a variable that help check if changes were made to the objects inside the heap\\n if unsorted: #because i updated the variables but the heap wasn't maintained, i just heapify it again\\n heapify(vertexes) \\n #this is the part that saves the distance and route \\n if dest.get_dist() == float(\\\"inf\\\"): #if there is no route then we just return None\\n return None\\n u = dest\\n while u.get_prev() != None:\\n v = u.get_prev()\\n route.insert(0, v.get_specific_link(u)) \\n u = v\\n return route\",\n \"def connecting_graph(self, solution_graph, weight='cost', ignore_sources=False):\\n debut = time.time()\\n self.logger.info('start connecting graph')\\n\\n # we need an undirected graph\\n undirected_solution_graph = solution_graph.to_undirected()\\n\\n if self.old_network_graph is not None and self.modify_old_network:\\n undirected_solution_graph = nx.compose(nx.MultiGraph(self.old_network_graph), undirected_solution_graph)\\n\\n # if already connected\\n if nx.is_connected(undirected_solution_graph) == True:\\n self.logger.info(\\\"the solution graph is already connected\\\")\\n return []\\n\\n # Computing the minimum sources in each component and all junction nodes in the solution graph\\n nodetype = nx.get_node_attributes(undirected_solution_graph, config.NODE_TYPE_KEY)\\n list_sources = [node for node in nodetype if nodetype[node] == config.SUPPLY_NODE_TYPE]\\n\\n # 1. Search of all connected subgraphs\\n if not ignore_sources:\\n reduced_list_sources = []\\n while len(list_sources) > 0:\\n source, is_isolated = list_sources.pop(0), True\\n for i in range(len(list_sources)):\\n is_isolated = is_isolated and not (nx.has_path(undirected_solution_graph, source, list_sources[i]))\\n if is_isolated:\\n reduced_list_sources.append(source)\\n else:\\n reduced_list_sources = [list(n)[0] for n in nx.connected_components(undirected_solution_graph)]\\n\\n # 2. Creation of all convex hulls for each source in reduced_list_sources\\n hulls = {}\\n for source in reduced_list_sources:\\n coord_compo = {}\\n nodes_connecting_source = nx.node_connected_component(undirected_solution_graph, source)\\n for node in nodes_connecting_source:\\n xy = tuple(self.optimization_graph.get_node_coordinates(node))\\n coord_compo[xy] = node\\n if len(coord_compo) > 2:\\n convexhull = ConvexHull(list(coord_compo.keys())).points\\n else:\\n convexhull = list(coord_compo.keys())\\n hulls[source] = [coord_compo[tuple(coord)] for coord in convexhull]\\n\\n # 3. Create list of possible list_edges_to_add\\n list_edges_to_add = {} # list of {(S1, S2):(length_of_SP, edges_to_add)}\\n\\n for S1, S2 in combinations(reduced_list_sources, 2):\\n\\n # change weight of edges\\n for i in range(len(hulls[S1])-1):\\n u,v = hulls[S1][i], hulls[S1][i+1]\\n self.optimization_graph.add_edge(u,v,key=-1,weight=0)\\n self.optimization_graph.add_edge(hulls[S1][-1],hulls[S1][0],key=-1,weight=0)\\n for i in range(len(hulls[S2])-1):\\n u,v = hulls[S2][i], hulls[S2][i+1]\\n self.optimization_graph.add_edge(u,v,key=-1,weight=0)\\n self.optimization_graph.add_edge(hulls[S2][-1],hulls[S2][0],key=-1,weight=0)\\n\\n # find the shortest path\\n source, target = hulls[S1][0], hulls[S2][0] # it's a choice to take 0, but no matter\\n try:\\n length, path = nx.single_source_dijkstra(self.optimization_graph, source, target=target, weight=weight)\\n except nx.NetworkXNoPath:\\n self.logger.info(\\\"Source \\\" + str(S1) + \\\" and source \\\" + str(S2) + \\\" can't be connected\\\")\\n return []\\n list_weights = nx.get_edge_attributes(self.optimization_graph, weight)\\n\\n # edges to add to connect S1 and S2\\n edges_to_add = []\\n for i in range(len(path) - 1):\\n u, v = path[i], path[i + 1]\\n # if the edge between (u,v) is not artificial, we add it\\n if list_weights.get((u, v, -1), None) != 0 and list_weights.get((u, v, 0), None) is not None:\\n edges_to_add.append((u, v, 0))\\n if list_weights.get((v, u, -1), None) != 0 and list_weights.get((v, u, 0), None) is not None:\\n edges_to_add.append((v, u, 0))\\n list_edges_to_add[(S1, S2)] = (length, edges_to_add)\\n\\n # change weight of edges\\n for i in range(len(hulls[S1])-1):\\n u,v = hulls[S1][i], hulls[S1][i+1]\\n self.optimization_graph.remove_edge(u,v,key=-1)\\n self.optimization_graph.remove_edge(hulls[S1][-1],hulls[S1][0],key=-1)\\n for i in range(len(hulls[S2])-1):\\n u,v = hulls[S2][i], hulls[S2][i+1]\\n self.optimization_graph.remove_edge(u,v,key=-1)\\n self.optimization_graph.remove_edge(hulls[S2][-1],hulls[S2][0],key=-1)\\n\\n\\n # 4. choice of best edges to add (Kruskal)\\n G = nx.Graph()\\n for (S1, S2) in list_edges_to_add:\\n (length, _) = list_edges_to_add[(S1, S2)]\\n if not G.has_node(S1):\\n G.add_node(S1)\\n if not G.has_node(S2):\\n G.add_node(S2)\\n G.add_edge(S1, S2, weight=length)\\n\\n reduced_list_edges_to_add = set()\\n T = nx.minimum_spanning_tree(G)\\n for u, v in T.edges:\\n if (u, v) in list_edges_to_add:\\n reduced_list_edges_to_add = reduced_list_edges_to_add.union(set(list_edges_to_add[(u, v)][1]))\\n if (v, u) in list_edges_to_add:\\n reduced_list_edges_to_add = reduced_list_edges_to_add.union(set(list_edges_to_add[(v, u)][1]))\\n\\n self.logger.info('end connecting graph in ' + str(time.time() - debut) + ' s')\\n return list(reduced_list_edges_to_add)\",\n \"def randnet(G):\\n\\t\\n\\t#initializationo of the lists\\n\\telst = G.get_edgelist()\\n\\tclst = G.es['color'][:]\\n\\tcdic = {}\\n\\tfor i,c in enumerate(clst):\\n\\t\\tcdic[c]=i\\n\\tlst1 = [[]]*len(key)\\n\\tfor i,e in enumerate(elst):\\n\\t\\tlst1[cdic[clst[i]]].append([e[0],e[1]])\\n\\t\\t\\n\\t#randomization procedure\\n\\tfor i in range(random.randrange(100,200)):\\n\\t\\tcid = cdic[random.choice(clst)] #random choice weighted by the frequency of each color\\n\\t\\te1id = random.randrange(0,len(lst1[cid])) #random choice of edge with that color\\n\\t\\te2id = random.randrange(0,len(lst1[cid]))\\n\\t\\textop = random.randrange(0,2)#random choice of top/bottom\\n\\t\\tttemp = lst1[cid][e1id][extop]\\n\\t\\tlst1[cid][e1id][extop] = lst1[cid][e2id][extop]\\n\\t\\tlst1[cid][e2id][extop] = ttemp\\n\\t\\n\\tcoutlst = []\\n\\teoutlst\\t= []\\n\\tfor i in range(len(lst1)):\\n\\t\\tc = clst[i]\\n\\t\\tfor e in lst1[i]:\\n\\t\\t\\tcoutlst.append(c)\\n\\t\\t\\teoutlst.append((e[0],e[1]))\\n\\n\\treturn [eoutlst,coutlst]\",\n \"def _ism_get_mirror_sources(source, receiver, walls, order_threshold, mirrors_threshold):\\n logger.info(\\\"_ism_get_mirror_sources: Determining mirror sources.\\\")\\n model = ism.Model(walls=walls, source=source, receiver=receiver, max_order=order_threshold)\\n mirrors = model.determine(strongest=mirrors_threshold)\\n yield from mirrors\",\n \"def gen_task_sets_simplegen(nsets):\\n start = time()\\n eval_task_sets = []\\n for util in utils:\\n task_sets = []\\n for i in range(nsets):\\n ts = synth.simplegen(i, util, implicit_deadlines=True)\\n synth.synth_c_pmf(ts, distribution_cls=lib.ExpExceedDist)\\n synth.set_fixed_priorities(ts)\\n task_sets.append(ts)\\n eval_task_sets.append(task_sets)\\n stop = time()\\n print('Task Set Generation SimpleGen: %.3fs' % (stop - start))\\n pickle.dump(eval_task_sets, open(task_sets_path + 'task_sets_simplegen', 'wb'))\",\n \"def _measure(d, sources, target, niter=25, bound=None):\\n uniques = {}\\n for source in sources:\\n others = list(sources)\\n others.remove(source)\\n others = list(flatten(others))\\n uniques[source] = two_way_skar(d, [source, target], others)\\n return uniques\",\n \"def _graph_fn_sample_stochastic(distribution):\\n return distribution.sample()\",\n \"def dfs_edges_generator(graph, source, reverse=...):\\n ...\",\n \"def get_all_sghop_info (nffg, return_paths=False):\\n sg_map = {}\\n for i in nffg.infras:\\n for p in i.ports:\\n for fr in p.flowrules:\\n # if fr.external:\\n # continue\\n if fr.id not in sg_map:\\n # The path is unordered!!\\n path_of_shop = []\\n flowclass = NFFGToolBox._extract_flowclass(fr.match.split(\\\";\\\"))\\n sg_map[fr.id] = [None, None, flowclass, fr.bandwidth, fr.delay]\\n # We have to find the BEGINNING of this flowrule sequence.\\n inbound_link = NFFGToolBox._find_infra_link(nffg, p, outbound=False,\\n accept_dyn=True)\\n while inbound_link.type != 'DYNAMIC':\\n path_of_shop.append(inbound_link)\\n if inbound_link.src.node.type == 'SAP':\\n break\\n # The link is STATIC, and its src is not SAP so it is an Infra.\\n prev_fr, prev_p = \\\\\\n NFFGToolBox._get_flowrule_and_its_starting_port(\\n inbound_link.src.node, fr.id)\\n NFFGToolBox._check_flow_consistencity(sg_map, prev_fr)\\n inbound_link = NFFGToolBox._find_infra_link(nffg, prev_p,\\n outbound=False,\\n accept_dyn=True)\\n # 'inbound_link' is DYNAMIC here or it is STATIC and starts from\\n # a SAP,\\n # so the sequence starts here\\n sg_map[fr.id][0] = inbound_link.src\\n\\n # We have to find the ENDING of this flowrule sequence.\\n output_port = NFFGToolBox._get_output_port_of_flowrule(i, fr)\\n if output_port is None:\\n continue\\n outbound_link = NFFGToolBox._find_infra_link(nffg, output_port,\\n outbound=True,\\n accept_dyn=True)\\n while outbound_link.type != 'DYNAMIC':\\n path_of_shop.append(outbound_link)\\n if outbound_link.dst.node.type == 'SAP':\\n break\\n # The link is STATIC and its dst is not a SAP so it is an Infra.\\n next_fr, _ = NFFGToolBox._get_flowrule_and_its_starting_port(\\n outbound_link.dst.node, fr.id)\\n # '_' is 'outbound_link.dst'\\n next_output_port = NFFGToolBox._get_output_port_of_flowrule(\\n outbound_link.dst.node, next_fr)\\n NFFGToolBox._check_flow_consistencity(sg_map, next_fr)\\n outbound_link = NFFGToolBox._find_infra_link(nffg,\\n next_output_port,\\n outbound=True,\\n accept_dyn=True)\\n # the 'outbound_link' is DYNAMIC here or finishes in a SAP, so the\\n # flowrule sequence finished here.\\n sg_map[fr.id][1] = outbound_link.dst\\n\\n if return_paths:\\n sg_map[fr.id].append(path_of_shop)\\n\\n return sg_map\",\n \"def randomNetwork(self, numVertices, numEdges, capacityRange):\\r\\n for _ in range(numEdges):\\r\\n fromVertex, toVertex = None, None\\r\\n while fromVertex == toVertex or (fromVertex, toVertex) in self.capacity:\\r\\n fromVertex = randint(1, numVertices)\\r\\n toVertex = randint(1, numVertices)\\r\\n capacity = randint(1, capacityRange) \\r\\n self.addEdge(fromVertex, toVertex, capacity)\",\n \"def sample_paths(S0, N, u, d, q, M):\\n value = S0*np.ones((M,1)) # M sample paths at once\\n paths = np.zeros((M, N+1))\\n paths[:,0] = value[:,0]\\n for i in np.arange(1, N+1,1): # time steps\\n random_values = bernoulli.rvs(size=(M,1),p=q)\\n up_moves = random_values*u\\n down_moves = -1*(random_values-1)*d \\n value = np.multiply(value,up_moves+down_moves)\\n paths[:,i] = value[:,0]\\n return paths\",\n \"def _compute_flows(paths):\\n assert isinstance(paths, list)\\n\\n # allocate memory\\n flows = np.zeros([len(paths), FLAGS.target_height, FLAGS.target_width, 2],\\n dtype=np.float32)\\n\\n # load all images\\n pbar = ProgressBar(max_value=len(paths))\\n for i in range(len(paths)-1):\\n im1 = skimage.io.imread(paths[i])\\n im2 = skimage.io.imread(paths[i+1])\\n\\n im1 = cv2.cvtColor(im1, cv2.COLOR_RGB2GRAY)\\n im2 = cv2.cvtColor(im2, cv2.COLOR_RGB2GRAY)\\n im1 = skimage.transform.resize(\\n im1, [FLAGS.target_height, FLAGS.target_width], preserve_range=True,\\n mode='constant', anti_aliasing=True)\\n im2 = skimage.transform.resize(\\n im2, [FLAGS.target_height, FLAGS.target_width], preserve_range=True,\\n mode='constant', anti_aliasing=True)\\n flow = cv2.calcOpticalFlowFarneback(\\n im1, im2, flow=None, pyr_scale=0.5, levels=3, winsize=15,\\n iterations=3, poly_n=5, poly_sigma=1.2, flags=0)\\n\\n # store images\\n flows[i] = flow\\n pbar.update(i)\\n\\n # Replicate the flow for last frame\\n flows[-1] = flow\\n return flows\",\n \"def sources(self):\\n return [x for x in self if self.in_degree(x)==0]\",\n \"def get_flows(self, num_flows_per_entry):\\n flows = []\\n for tenant in self._tenants:\\n for contract in tenant.get_children(only_class=Contract):\\n providing_epgs = contract.get_all_providing_epgs()\\n consuming_epgs = contract.get_all_consuming_epgs()\\n for providing_epg in providing_epgs:\\n vlan_ifs = providing_epg.get_all_attached(L2Interface)\\n if len(vlan_ifs):\\n providing_vlan = vlan_ifs[0].encap_id\\n phys_ifs = vlan_ifs[0].get_all_attached(Interface)\\n if len(phys_ifs):\\n providing_phys_if = phys_ifs[0].name\\n for consuming_epg in consuming_epgs:\\n vlan_ifs = consuming_epg.get_all_attached(L2Interface)\\n if len(vlan_ifs):\\n consuming_vlan = vlan_ifs[0].encap_id\\n phys_ifs = vlan_ifs[0].get_all_attached(Interface)\\n if len(phys_ifs):\\n consuming_phys_if = phys_ifs[0].name\\n if providing_vlan == consuming_vlan and providing_phys_if == consuming_phys_if:\\n # Skip this case since traffic would be switched outside fabric\\n continue\\n for filter_entry in contract.get_all_filter_entries():\\n for i in range(0, num_flows_per_entry):\\n flow = Flow()\\n flow.ethertype = filter_entry.etherT\\n if flow.ethertype == 'arp':\\n flow.arp_opcode = filter_entry.arpOpc\\n flow.populate_random_ip_addresses()\\n elif flow.ethertype == 'ip':\\n flow.populate_random_ip_addresses()\\n flow.proto = filter_entry.prot\\n if flow.proto == '6' or flow.proto == '17':\\n dFromPort = int(filter_entry.dFromPort)\\n dToPort = int(filter_entry.dToPort)\\n sFromPort = int(filter_entry.sFromPort)\\n sToPort = int(filter_entry.sToPort)\\n if dFromPort == 0:\\n dFromPort = 1\\n dToPort += 1\\n if sFromPort == 0:\\n sFromPort = 1\\n sToPort += 1\\n if dToPort > 65534:\\n dToPort = 65534\\n if sToPort > 65534:\\n sToPort = 65534\\n flow.dport = str(random_number(dFromPort,\\n dToPort))\\n flow.sport = str(random_number(sFromPort,\\n sToPort))\\n if flow.proto == '6':\\n flow.tcp_rules = filter_entry.tcpRules\\n flow.svlan = providing_vlan\\n flow.dvlan = consuming_vlan\\n flow.src_intf = providing_phys_if\\n flow.dst_intf = consuming_phys_if\\n\\n # Is the flow expected to succeed ?\\n flow.expected_action = 'drop'\\n providing_bd = providing_epg.get_bd()\\n consuming_bd = consuming_epg.get_bd()\\n if providing_bd and consuming_bd:\\n if providing_bd == consuming_bd:\\n if providing_bd.get_context() == consuming_bd.get_context():\\n flow.expected_action = 'permit'\\n flow.populate_random_mac_addresses()\\n flows.append(flow)\\n return flows\",\n \"def compute_shortest_routes(start_ids, dest_ids, G):\\n return ox.distance.shortest_path(G, start_ids, dest_ids, weight='travel_time', cpus=6)\",\n \"def shortest_steps(connectors: List[int]):\\n connectors = sorted(connectors)\\n return [nxt-prv for prv, nxt in zip([0]+connectors, connectors)] + [3]\",\n \"def shortest_path_bfs_list_list(dic_adj_graph, source_list, destination_list):\\r\\n\\tvisited = set()\\r\\n\\tqueue = collections.deque([])\\r\\n\\tfor node in source_list:\\r\\n\\t visited.add((node, node))\\r\\n\\t queue.append((node, 0, node))\\r\\n\\tjumps_list = [] # To store the number of jumps of each node in desination_list\\r\\n\\r\\n\\t# Repeat until queue is empty\\r\\n\\twhile queue: \\r\\n\\t vertex = queue.popleft() # 0:node - 1:level - 2:initial_node\\r\\n\\t # If vertex is destionation return level\\r\\n\\t if vertex[0] in destination_list:\\r\\n\\t jumps_list.append(vertex[1])\\r\\n\\t # Add to visited and append to queue\\r\\n\\t for neighbour in dic_adj_graph[vertex[0]]: \\r\\n\\t if (neighbour, vertex[2]) not in visited: \\r\\n\\t visited.add((neighbour, vertex[2])) \\r\\n\\t queue.append((neighbour, vertex[1]+1, vertex[2])) \\r\\n\\treturn jumps_list\",\n \"def genChunkTestSets(data, nSets, ws, gapSize, dirName=\\\"test_data/\\\", ofCut=0.9):\\n # Start times for windows with at least ofCut of data observed\\n tOFCut = np.where(windowObsFrac(data, ws) > ofCut)[0]\\n\\n # Choose times for test intervals\\n np.random.seed(np.random.randint(0, 100))\\n sampleTs = np.random.choice(tOFCut, size=nSets, replace=False)\\n\\n for ti in sampleTs:\\n # Randomly select a sensor\\n sensor = np.random.randint(0, data.shape[1])\\n # Remove some data to use for testing\\n _, removedTimes = removeChunk(data, ti, ws, sensor, gapSize)\\n\\n # Save data in csvs\\n np.savetxt(dirName + \\\"/ti=%i_tf=%i_sensor=%i.csv\\\"%(ti, ti+ws, sensor), removedTimes, \\\\\\n delimiter=\\\" \\\", fmt=\\\"%i\\\")\",\n \"def random_path(length):\\n assert length > 0\\n edges = [Variable('ve%d' % i) for i in range(1, length + 1)]\\n nodes = [Variable('vn%d' % i) for i in range(1, length)] + [TARGET_VAR]\\n s = SOURCE_VAR # start at source\\n triples = []\\n for e, n in zip(edges, nodes):\\n triples.append((s, e, n))\\n s = n\\n gp = GraphPattern([\\n (o, p, s) if random.random() < .5 else (s, p, o)\\n for s, p, o in triples\\n ])\\n return gp\",\n \"def generate_visiting_scheme(self):\\n\\n def all_indices_shuffled():\\n _res = list(range(self.dataset.num_examples))\\n self.rnd.shuffle(_res)\\n return _res\\n\\n # noinspection PyUnusedLocal\\n _tmp_ts = np.concatenate(\\n [all_indices_shuffled() for _ in range(self.epochs or 1)]\\n )\\n self.training_schedule = (\\n _tmp_ts\\n if self.training_schedule is None\\n else np.concatenate([self.training_schedule, _tmp_ts])\\n ) # do not discard previous schedule,\\n # this should allow backward passes of arbitrary length\\n\\n return self\",\n \"def Generate_edges(size, connectedness):\\r\\n\\r\\n assert connectedness <= 1\\r\\n random.seed(10)\\r\\n for i in range(size):\\r\\n for j in range(i + 1, size):\\r\\n if random.randrange(0, 100) <= connectedness * 100:\\r\\n yield f'{i} {j}'\",\n \"def _get_allow_all_flows() -> List[FlowDescription]:\\n return [\\n # Set flow match for all packets\\n # Don't set the app_name field\\n FlowDescription( # uplink flow\\n match=FlowMatch(\\n direction=FlowMatch.Direction.Value(\\\"UPLINK\\\"),\\n ),\\n action=FlowDescription.Action.Value(\\\"PERMIT\\\"),\\n ),\\n FlowDescription( # downlink flow\\n match=FlowMatch(\\n direction=FlowMatch.Direction.Value(\\\"DOWNLINK\\\"),\\n ),\\n action=FlowDescription.Action.Value(\\\"PERMIT\\\"),\\n ),\\n ]\",\n \"def connect(src, *destinations, exclude=set(), fit=False):\\n assignemnts = []\\n for dst in destinations:\\n assignemnts.extend(_connect(src, dst, exclude, fit))\\n \\n return assignemnts\",\n \"def shuffle(self):\\n self.edges = np.random.permutation(self.edges)\\n self.batch_num = 0\",\n \"def generate_parameters_random_walk():\\r\\n\\r\\n logging.info('Loading distances_nets from disk...')\\r\\n\\r\\n\\r\\n\\r\\n sum_weights = {}\\r\\n\\r\\n amount_edges = {}\\r\\n\\r\\n\\r\\n\\r\\n layer = 0\\r\\n\\r\\n while is_pickle('distances_nets_weights-layer-' + str(layer)):\\r\\n\\r\\n logging.info('Executing layer {}...'.format(layer))\\r\\n\\r\\n weights = restore_variable_from_disk('distances_nets_weights-layer-' + str(layer))\\r\\n\\r\\n\\r\\n\\r\\n for node, list_weights in weights.items():\\r\\n\\r\\n if layer not in sum_weights:\\r\\n\\r\\n sum_weights[layer] = 0\\r\\n\\r\\n if layer not in amount_edges:\\r\\n\\r\\n amount_edges[layer] = 0\\r\\n\\r\\n\\r\\n\\r\\n for w in list_weights:\\r\\n\\r\\n sum_weights[layer] += w\\r\\n\\r\\n amount_edges[layer] += 1\\r\\n\\r\\n\\r\\n\\r\\n logging.info('Layer {} executed.'.format(layer))\\r\\n\\r\\n layer += 1\\r\\n\\r\\n\\r\\n\\r\\n average_weight = {}\\r\\n\\r\\n for layer in sum_weights.keys():\\r\\n\\r\\n average_weight[layer] = sum_weights[layer] / amount_edges[layer]\\r\\n\\r\\n\\r\\n\\r\\n logging.info(\\\"Saving average_weights on disk...\\\")\\r\\n\\r\\n save_variable_on_disk(average_weight, 'average_weight')\\r\\n\\r\\n\\r\\n\\r\\n amount_neighbours = {}\\r\\n\\r\\n\\r\\n\\r\\n layer = 0\\r\\n\\r\\n while is_pickle('distances_nets_weights-layer-' + str(layer)):\\r\\n\\r\\n logging.info('Executing layer {}...'.format(layer))\\r\\n\\r\\n weights = restore_variable_from_disk('distances_nets_weights-layer-' + str(layer))\\r\\n\\r\\n\\r\\n\\r\\n amount_neighbours[layer] = {}\\r\\n\\r\\n\\r\\n\\r\\n for node, list_weights in weights.items():\\r\\n\\r\\n cont_neighbours = 0\\r\\n\\r\\n for w in list_weights:\\r\\n\\r\\n if w > average_weight[layer]:\\r\\n\\r\\n cont_neighbours += 1\\r\\n\\r\\n amount_neighbours[layer][node] = cont_neighbours\\r\\n\\r\\n\\r\\n\\r\\n logging.info('Layer {} executed.'.format(layer))\\r\\n\\r\\n layer += 1\\r\\n\\r\\n\\r\\n\\r\\n logging.info(\\\"Saving amount_neighbours on disk...\\\")\\r\\n\\r\\n save_variable_on_disk(amount_neighbours, 'amount_neighbours')\",\n \"def traverse_graph(F, f, s, t, u, sr):\\n def get_paths_for_flow(F, s, f):\\n \\\"\\\"\\\"\\n RETURNS\\n A set of outgoing links and corresponding splitting ratios for flow f\\n at node s\\n \\\"\\\"\\\"\\n links = [((u, v), split_ratio) \\n for (flow_id, u, v), split_ratio in F.items() \\n if flow_id == f and u == s and split_ratio > 0.001]\\n return links\\n \\n if u == t:\\n return [([t], sr)]\\n\\n outgoing_links = get_paths_for_flow(F, u, f)\\n paths_to_t = []\\n\\n for ((current_node, next_hop), split_ratio) in outgoing_links:\\n paths_from_u_to_t = traverse_graph(F, f, s, t, next_hop, split_ratio) \\n paths_to_t.extend(paths_from_u_to_t)\\n\\n paths_to_t_with_u = []\\n for path in paths_to_t:\\n nodes, sr = path\\n new_path = [u] + nodes\\n paths_to_t_with_u.append((new_path, sr))\\n\\n return paths_to_t_with_u\",\n \"def generate(\\n self,\\n num_nodes_src_set: int,\\n num_nodes_dst_set: int,\\n num_edges_src_dst: int,\\n num_edges_dst_src: int,\\n is_directed: bool,\\n return_node_ids: bool = False,\\n transform_graph: bool = True,\\n *args,\\n **kwargs,\\n ):\\n raise NotImplementedError()\",\n \"def djikstra(self, source, target):\\r\\n dist = {}\\r\\n prev = {}\\r\\n set_q = {}\\r\\n for vertex in self.vertices.keys():\\r\\n dist[vertex] = sys.maxsize\\r\\n prev[vertex] = None\\r\\n set_q[vertex] = dist[vertex]\\r\\n dist[source] = 0\\r\\n set_q[source] = 0\\r\\n while set_q:\\r\\n vertex_u = min(set_q, key=set_q.get)\\r\\n if vertex_u == target:\\r\\n break\\r\\n set_q.pop(vertex_u)\\r\\n for edge in self.edges[vertex_u]:\\r\\n alt = dist[vertex_u] + edge.distance\\r\\n if alt < dist[edge.destination]:\\r\\n dist[edge.destination] = alt\\r\\n set_q[edge.destination] = dist[edge.destination]\\r\\n prev[edge.destination] = vertex_u\\r\\n path = []\\r\\n vertex_u = target\\r\\n while prev[vertex_u]:\\r\\n path.insert(0, vertex_u)\\r\\n vertex_u = prev[vertex_u]\\r\\n path.insert(0, vertex_u)\\r\\n return path\",\n \"def min_path(vs, es, source, target):\\n dijkstra(vs, es, source, stop = target)\\n test = target\\n result = []\\n while test != source:\\n e = test._ss_edge\\n result.append(e)\\n test = e.v1 if e.v1 != test else e.v2\\n assert test == source and test._ss_edge is None\\n return result[::-1]\",\n \"def _get_paths(G, nodes, edges, target, weight, available_dist, cache={}):\\n\\n G_succ = G.succ if G.is_directed() else G.adj\\n\\n output = []\\n visited = set(nodes)\\n path_info = []\\n source = nodes[-1]\\n get_weight = _create_weight_func(G, weight)\\n\\n for neighbor, neighbor_edge in G_succ[source].items():\\n\\n if neighbor in visited:\\n continue\\n\\n new_available_dist = available_dist - get_weight(source, neighbor)\\n\\n if new_available_dist < 0:\\n continue\\n\\n # shortest path key for cache\\n sp_key = (source, neighbor, target)\\n\\n if sp_key not in cache:\\n sp = dijkstra(G, neighbor, target, 'length', set([source]), \\n new_available_dist)\\n\\n cache[sp_key] = INF if not sp else sp[1]\\n\\n if new_available_dist < cache[sp_key]:\\n continue\\n\\n path_info.append((neighbor, neighbor_edge, new_available_dist))\\n\\n\\n for (neighbor, neighbor_edge, new_available_dist) in path_info:\\n new_path = nodes + [neighbor]\\n new_edges = edges + [neighbor_edge]\\n\\n if neighbor == target:\\n output.append((new_path, new_edges))\\n else:\\n output.extend(_get_paths(G, new_path, new_edges, target, \\n weight, new_available_dist, cache))\\n\\n return output\",\n \"def sample_edge_uniform(adj_list, degrees, n_triplets, sample_size):\\n all_edges = np.arange(n_triplets)\\n return np.random.choice(all_edges, sample_size, replace=False)\",\n \"def get_diffuse_sources(self, src_sel):\\n extended = self._select_and_freeze(self.extended_sources, src_sel)\\n for s in extended: # this seems redundant, but was necessary\\n s.model.free[:] = False if src_sel.frozen(s) else s.free[:]\\n sources.validate(s,self.nside, None)\\n s.smodel = s.model\\n \\n return self.get_global_sources(src_sel.skydir()), extended\",\n \"def select_seeds(self, graph, k):\\n raise NotImplementedError\\n return set()\",\n \"def testSierpinski(self):\\n G = self.twistedLadder(4) # Complete graph on four vertices\\n for i in range(3):\\n G = self.truncate(G)\\n self.check(G,3)\",\n \"def shortestPath(self, source, target):\\n dist = {}\\n prev = {}\\n q = []\\n for y,a in enumerate(self.sm):\\n for x,b in enumerate(self.sm[y]):\\n dist[(x,y)] = sys.maxint\\n prev[(x,y)] = None\\n q.append((x,y))\\n dist[source] = 0\\n\\n while len(q) is not 0:\\n # find the node with minimum value (u)\\n d = deepcopy(dist)\\n while True:\\n b = dict(map(lambda item: (item[1],item[0]), d.items()))\\n u = b[min(b.keys())]\\n if u not in q:\\n d.pop(u)\\n else:\\n break\\n\\n if dist[u] == sys.maxint: # remaining nodes are inaccessible\\n break\\n\\n q.remove(u)\\n\\n\\n if u == target: # target found\\n break\\n\\n for v in self.getNeighbors(u):\\n alt = dist[u] + 1\\n if alt < dist[v]:\\n dist[v] = alt\\n prev[v] = u\\n\\n s = []\\n u = target\\n while prev[u] is not None:\\n s.append(u)\\n u = prev[u]\\n s.reverse()\\n\\n return s\",\n \"def transfer_funds_randomly():\\n\\n source_id = get_random_account_id()\\n sink_id = get_random_account_id()\\n\\n source = Account.get(id=source_id)\\n amount = floor(source.balance / 2)\\n\\n if source.balance < amount:\\n raise \\\"Insufficient funds\\\"\\n\\n source.balance -= amount\\n sink = Account.get(id=sink_id)\\n sink.balance += amount\",\n \"def prepare_k_fold(self, k_fold: int, shuffle: bool = True) \\\\\\n -> List[Tuple[ZLIMGS, ZLIMGS, ZLIMGS, ZLIMGS, ZLIMGS, ZLIMGS]]:\\n if self.setting == 'setting1':\\n warnings.warn(\\\"Setting 1 should not use train eval dataset! \\\"\\n \\\"Because its training set only contain normal samples!\\\")\\n\\n with open(self.json_path) as fp:\\n ids_json = json.load(fp)\\n ids_train_normal = ids_json['normal']['train']\\n ids_train_defect = ids_json['defect']['train']\\n\\n if shuffle:\\n self.rnd.shuffle(ids_train_normal)\\n self.rnd.shuffle(ids_train_defect)\\n ids_folds_normal = chunks(ids_train_normal, k_fold)\\n ids_folds_defect = chunks(ids_train_defect, k_fold)\\n\\n zlimgs_folds = []\\n for k in range(k_fold):\\n _ids_folds_normal = ids_folds_normal.copy()\\n _ids_folds_defect = ids_folds_defect.copy()\\n ids_k_dev_normal = _ids_folds_normal.pop(k)\\n ids_k_dev_defect = _ids_folds_defect.pop(k)\\n ids_k_train_normal = list(itertools.chain(*_ids_folds_normal))\\n ids_k_train_defect = list(itertools.chain(*_ids_folds_defect))\\n\\n # train\\n zlimgs_k_train_normal = self._create_zl_imgs_given_ids(ids=ids_k_train_normal,\\n subset=CONFIG[self.setting]['normal_train'],\\n ann_type=CONFIG[self.setting]['ann_train'])\\n zlimgs_k_train_defect = self._create_zl_imgs_given_ids(ids=ids_k_train_defect,\\n subset=CONFIG[self.setting]['defect_train'],\\n ann_type=CONFIG[self.setting]['ann_train'])\\n # train-eval\\n zlimgs_k_train_eval_normal = self._create_zl_imgs_given_ids(ids=ids_k_train_normal,\\n subset=CONFIG[self.setting]['normal_train'],\\n ann_type=CONFIG[self.setting]['ann_eval'])\\n zlimgs_k_train_eval_defect = self._create_zl_imgs_given_ids(ids=ids_k_train_defect,\\n subset=CONFIG[self.setting]['defect_train'],\\n ann_type=CONFIG[self.setting]['ann_eval'])\\n # dev\\n zlimgs_k_dev_normal = self._create_zl_imgs_given_ids(ids=ids_k_dev_normal, subset='dev',\\n ann_type=CONFIG[self.setting]['ann_eval'])\\n zlimgs_k_dev_defect = self._create_zl_imgs_given_ids(ids=ids_k_dev_defect, subset='dev',\\n ann_type=CONFIG[self.setting]['ann_eval'])\\n zlimgs_folds.append((zlimgs_k_train_normal, zlimgs_k_train_defect,\\n zlimgs_k_train_eval_normal, zlimgs_k_train_eval_defect,\\n zlimgs_k_dev_normal, zlimgs_k_dev_defect))\\n return zlimgs_folds\",\n \"def shuffle(self):\\n for edge_type in self.edge_types:\\n for k in range(self.edge_types[edge_type]):\\n self.train_edges[edge_type][k] = np.random.permutation(self.train_edges[edge_type][k])\\n self.batch_num[self.edge_type2idx[edge_type[0], edge_type[1], k]] = 0\\n self.current_edge_type_idx = 0\\n self.freebatch_edge_types = list(range(self.num_edge_types))\\n self.freebatch_edge_types.remove(self.edge_type2idx[0, 0, 0])\\n self.freebatch_edge_types.remove(self.edge_type2idx[0, 1, 0])\\n self.freebatch_edge_types.remove(self.edge_type2idx[1, 0, 0])\\n self.iter = 0\",\n \"def FixedInGraph(N,degrees,replace = True):\\n \\n conn = np.zeros([N*degrees,2])\\n nodes = np.arange(0,N)\\n ii = 0\\n for i in range(N):\\n # for deg in range(degrees):\\n source = np.random.choice(nodes,size =degrees,replace=replace)\\n conn[ii:ii+len(source),0] = source\\n conn[ii:ii+len(source),1] = i\\n ii+=len(source) \\n return conn\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6073624","0.5772932","0.56998974","0.5527996","0.54848486","0.5443951","0.5443951","0.53789777","0.53648436","0.53508836","0.5280728","0.5269755","0.5099018","0.50866324","0.50755084","0.50711346","0.50711346","0.50291127","0.5007661","0.4996117","0.49696457","0.49682721","0.49646184","0.49446902","0.49350876","0.4915417","0.4906965","0.4900397","0.4894073","0.4883474","0.4870449","0.4869778","0.48629153","0.48522472","0.48414975","0.48375353","0.48368937","0.483668","0.48259526","0.48205796","0.4819207","0.48170552","0.48148367","0.47995052","0.4789559","0.4782901","0.4781354","0.47812265","0.4781","0.47781774","0.47750148","0.47739777","0.4773776","0.47692326","0.47692242","0.47664964","0.47586358","0.4758619","0.47579163","0.4755813","0.47539485","0.4753161","0.47531536","0.47507897","0.47489187","0.47451696","0.4739842","0.47376338","0.4732328","0.47315893","0.47304666","0.47255886","0.47221905","0.47148","0.4713653","0.4713324","0.47129184","0.47127834","0.470837","0.4704593","0.46998355","0.46935922","0.46844184","0.4670592","0.46702513","0.46680504","0.46550852","0.4652263","0.46451375","0.46447027","0.46397424","0.46374586","0.4635019","0.46290317","0.4628079","0.46269467","0.4626924","0.46260434","0.4623968","0.46179485"],"string":"[\n \"0.6073624\",\n \"0.5772932\",\n \"0.56998974\",\n \"0.5527996\",\n \"0.54848486\",\n \"0.5443951\",\n \"0.5443951\",\n \"0.53789777\",\n \"0.53648436\",\n \"0.53508836\",\n \"0.5280728\",\n \"0.5269755\",\n \"0.5099018\",\n \"0.50866324\",\n \"0.50755084\",\n \"0.50711346\",\n \"0.50711346\",\n \"0.50291127\",\n \"0.5007661\",\n \"0.4996117\",\n \"0.49696457\",\n \"0.49682721\",\n \"0.49646184\",\n \"0.49446902\",\n \"0.49350876\",\n \"0.4915417\",\n \"0.4906965\",\n \"0.4900397\",\n \"0.4894073\",\n \"0.4883474\",\n \"0.4870449\",\n \"0.4869778\",\n \"0.48629153\",\n \"0.48522472\",\n \"0.48414975\",\n \"0.48375353\",\n \"0.48368937\",\n \"0.483668\",\n \"0.48259526\",\n \"0.48205796\",\n \"0.4819207\",\n \"0.48170552\",\n \"0.48148367\",\n \"0.47995052\",\n \"0.4789559\",\n \"0.4782901\",\n \"0.4781354\",\n \"0.47812265\",\n \"0.4781\",\n \"0.47781774\",\n \"0.47750148\",\n \"0.47739777\",\n \"0.4773776\",\n \"0.47692326\",\n \"0.47692242\",\n \"0.47664964\",\n \"0.47586358\",\n \"0.4758619\",\n \"0.47579163\",\n \"0.4755813\",\n \"0.47539485\",\n \"0.4753161\",\n \"0.47531536\",\n \"0.47507897\",\n \"0.47489187\",\n \"0.47451696\",\n \"0.4739842\",\n \"0.47376338\",\n \"0.4732328\",\n \"0.47315893\",\n \"0.47304666\",\n \"0.47255886\",\n \"0.47221905\",\n \"0.47148\",\n \"0.4713653\",\n \"0.4713324\",\n \"0.47129184\",\n \"0.47127834\",\n \"0.470837\",\n \"0.4704593\",\n \"0.46998355\",\n \"0.46935922\",\n \"0.46844184\",\n \"0.4670592\",\n \"0.46702513\",\n \"0.46680504\",\n \"0.46550852\",\n \"0.4652263\",\n \"0.46451375\",\n \"0.46447027\",\n \"0.46397424\",\n \"0.46374586\",\n \"0.4635019\",\n \"0.46290317\",\n \"0.4628079\",\n \"0.46269467\",\n \"0.4626924\",\n \"0.46260434\",\n \"0.4623968\",\n \"0.46179485\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62126094"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":24588,"cells":{"query":{"kind":"string","value":"Returns a list of flows with randomly selected sources and destinations that will saturate the network (i.e. a flow will be addmitted provided that it will not cause the utilization of any link in the network to exceed 1. Flows are split across the K least utilized paths connecting the source node to the destination node (i.e. this is a greedy algorithm)."},"document":{"kind":"string","value":"def compute_greedy_flow_allocations( target_graph\n , flow_selection_fn\n , seed_number=DEFAULT_SEED_NUMBER):\n\n flow_allocation_seed_number = seed_number\n np.random.seed(flow_allocation_seed_number)\n\n link_utilization = {tuple(sorted(link_tuple)): 0.0 for link_tuple in target_graph.edges}\n flows = []\n\n while True:\n capacity_was_exceeded = False\n\n source_node, destination_node = flow_selection_fn(target_graph.nodes)\n flow_tx_rate = np.random.uniform(FLOW_TX_RATE_LOWER_BOUND, FLOW_TX_RATE_UPPER_BOUND)\n\n connecting_paths = list(node_disjoint_paths(target_graph, source_node, destination_node))\n disjoint_path_count = len(connecting_paths)\n flow_rate_per_subpath = flow_tx_rate / disjoint_path_count\n for path in [nx.utils.pairwise(p_i) for p_i in connecting_paths]:\n for u, v in [tuple(sorted(t_i)) for t_i in path]:\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\n capacity_was_exceeded = True\n break\n link_utilization[u, v] += flow_rate_per_subpath\n if capacity_was_exceeded:\n break\n if capacity_was_exceeded:\n break\n\n the_flow = Flow( source_node = source_node\n , destination_node = destination_node\n , flow_tx_rate = flow_tx_rate\n , paths = connecting_paths\n , splitting_ratio = [1.0/disjoint_path_count]*disjoint_path_count\n )\n flows.append(the_flow)\n return flows, link_utilization"},"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 compute_path_hopping_flow_allocations(target_graph, K=3):\n flow_allocation_seed_number = 0xCAFE_BABE\n np.random.seed(flow_allocation_seed_number)\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n link_utilization = {(u, v): 0.0 for u, v in target_graph.edges}\n node_capacity = {u: 0.0 for u in target_graph.nodes}\n flows = []\n while True:\n source_node, destination_node = flow_selection_fn(target_graph.nodes, 2, replace=False)\n print(source_node, destination_node)\n\n shortest_paths = sorted(nx.all_simple_paths(target_graph, source_node, destination_node,\n cutoff=3),\n key=lambda p: len(p))\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\n\n # flow_tx_rate = np.random.uniform() * 10\n flow_tx_rate = 1.0\n # if node_capacity[source_node] + flow_tx_rate > LINK_CAPACITY:\n # break\n node_capacity[source_node] += flow_tx_rate\n capacity_was_exceeded = False \n for path in [nx.utils.pairwise(p_i) for p_i in k_shortest_paths]:\n for u, v in [sorted(h_i) for h_i in path]:\n flow_rate_per_subpath = flow_tx_rate / K\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\n capacity_was_exceeded = True\n break\n link_utilization[u, v] += flow_rate_per_subpath\n if capacity_was_exceeded:\n break\n\n if capacity_was_exceeded:\n break\n\n the_flow = Flow( source_node = source_node\n , destination_node = destination_node\n , flow_tx_rate = flow_tx_rate\n , paths = k_shortest_paths\n , splitting_ratio = [1.0/K]*K\n )\n flows.append(the_flow)\n return flows, link_utilization","def compute_equal_flow_allocations(target_graph, K=3):\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n flow_allocation_seed_number = 0xDEAD_BEEF\n np.random.seed(flow_allocation_seed_number)\n flows = []\n for node in target_graph.nodes:\n possible_destination_nodes = set(target_graph.nodes) - set([node])\n [destination_node] = np.random.choice(list(possible_destination_nodes), 1, replace=False)\n # shortest_paths = all_shortest_paths(target_graph, node, destination_node.item())\n shortest_paths = sorted(nx.all_simple_paths(target_graph, node, destination_node.item(),\n cutoff=3),\n key=lambda p: len(p))\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\n the_flow = Flow( source_node = node\n , destination_node = destination_node.item()\n , flow_tx_rate = 10.0\n , paths = k_shortest_paths\n , splitting_ratio = [1/K]*K\n )\n flows.append(the_flow)\n \n return flow_allocation_seed_number, flows","def bfsSample(G, source=None, k = 50):\n\twarn(\"networkit.sampling.bfsSample is deprecated, will be removed in future updates.\")\n\tif not source:\n\t\tsource = GraphTools.randomNode(G)\n\tn = G.numberOfNodes()\n\tvisited = [False]*n\n\tQ = [source]\n\tclosest = set([source])\n\tglobal found\n\tfound = 0\n\twhile len(Q) > 0 and found < k:\n\t\tu = Q.pop(0)\n\t\tdef enqueue(u,v,weight, eid):\n\t\t\tglobal found\n\t\t\tif not visited[v] and found < k:\n\t\t\t\tfound += 1\n\t\t\t\tvisited[v] = True\n\t\t\t\tQ.append(v)\n\t\t\t\tclosest.add(v)\n\t\tG.forEdgesOf(u, enqueue)\n\tprint(\"found {0} nodes\".format(len(closest)))\n\tG1 = GraphTools.subgraphFromNodes(G, closest)\n\treturn G1","def compute_unequal_flow_allocations(target_graph, K=3):\n\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n flow_allocation_seed_number = 0xDEAD_BEEF\n np.random.seed(flow_allocation_seed_number)\n flows = []\n link_utilization = {}\n for node in target_graph.nodes:\n possible_destination_nodes = set(target_graph.nodes) - {node}\n destination_node = np.random.choice(list(possible_destination_nodes), 1, \n replace=False).item()\n shortest_path = nx.shortest_path(target_graph, node, destination_node)\n the_flow = Flow( source_node = node\n , destination_node = destination_node\n , flow_tx_rate = 10.0\n , paths = [shortest_path]\n , splitting_ratio = [1.0]\n )\n flows.append(the_flow)\n\n return flow_allocation_seed_number, flows","def generate_graph(size, number_of_clusters, minimal_size):\n base_list = list(range(size))\n result_list = []\n random.shuffle(base_list)\n for i in range(number_of_clusters - 1):\n size = random.randint(minimal_size, len(base_list) - (number_of_clusters - i - 1) * minimal_size)\n cluster = []\n for n in range(size):\n actual = random.choice(base_list)\n base_list.remove(actual)\n cluster.append(actual)\n result_list.append(strongly_connect(cluster))\n result_list.append(strongly_connect(base_list))\n\n while len(result_list) < 5:\n result_list.append([])\n\n print(sorted([len(i) for i in result_list], reverse=True)[:5])\n\n return weak_connect_graph(result_list)","def get_pathologic_covering_routes(n_pl, n_target, attacker_strategy, target_values):\n # computes the coefficient used by the greedy oracle to choose routes\n targets_coeff = np.transpose(np.multiply(attacker_strategy, target_values))\n\n # randomly selects the player for which the non optimal choice will be made\n wrong_pl = randint(1, n_pl)\n\n # generate the non optimal route randomly\n n_covered_targets = randint(n_pl,n_target-1)\n non_opt_action = np.zeros(n_target)\n for i in range(0, n_covered_targets):\n random_covered_target = randint(0, n_target-1)\n non_opt_action[random_covered_target] = 1\n\n # compute the value of the non optimal route\n non_opt_val = get_value_single_route(non_opt_action, targets_coeff)\n\n # generate routes that have, as a single, values smaller than the best greedy route but taken togher perform\n # at least as well. [[0,1,...],[...],...] a[r][t]=1 iff t is covered by r.\n # The returned list should have n_pl - 1 routes\n opt_routes = get_opt_routes(n_pl, non_opt_action)\n\n I={}\n for pl in range(1, n_pl+1):\n\n n_r = randint(0, MAX_ROUTES)\n temp = lil_matrix((n_r+1, n_target), dtype='int8')\n\n if pl == wrong_pl:\n # put the non opt route in the bucket\n for t in non_opt_action.nonzero():\n temp[0,t] = 1\n else:\n for t in opt_routes.pop().nonzero():\n temp[0,t] = 1\n\n # generate other random routes with single value less than the non_opt_value\n for r in range(1, n_r):\n new_route = get_r_limited_val(non_opt_val, targets_coeff)\n\n for t in new_route.nonzero():\n temp[r,t] = 1\n\n I[pl] = temp.tocsr()\n\n return I","def multipleTravellingSalesmen(self, iterations=None):\n if not iterations:\n iterations = self.mTSPIterations\n\n # Randomly select points drawn from unvisited and distribute equally among the ships\n paths = self.partition(self.unvisited.keys(), len(self.ships))\n [path.append(ship) for path, ship in zip(paths, self.ships)]\n\n # Run single travelling salesman on each of the ships\n paths = [self.singleTravellingSalesman(path, iterations=0) for path in paths]\n\n\n # IF TWO OR MORE SHIPS!!!\n # Point exchange between ships and rerun tsp on each ship\n if len(self.ships) > 1:\n for _ in range(iterations):\n twopathindices = random.sample(xrange(len(paths)), 2)\n newtwopaths = self.swapTwoPointsBetweenPaths([paths[index] for index in twopathindices])\n newtwopaths = [self.singleTravellingSalesman(path, iterations=max(len(path), 100)) for path in\n newtwopaths]\n if self.totalPathDistance(newtwopaths) < self.totalPathDistance(\n [paths[index] for index in twopathindices]):\n for i, index in enumerate(twopathindices):\n paths[index] = newtwopaths[i]\n\n return paths","def get_paths_for_flow(F, s, f):\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links","def get_paths_for_flow(F, s, f):\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links","def set_random_session(self, G, degree_s):\n sorted_nodes = nx.topological_sort(G)\n num_nodes = G.number_of_nodes()\n\n # create sources and destinations of each of the sections\n # name the nodes to be the last 4 numbers\n srcs = [num_nodes, num_nodes + 1]\n dsts = [num_nodes + 2, num_nodes + 3]\n\n end_idx = int(0.3 * len(sorted_nodes))\n end_idx = max(end_idx, 2)\n for i in range(2):\n s = srcs[i]\n t = dsts[i]\n reachables = []\n iter_num = 0\n\n while len(reachables) == 0:\n iter_num += 1\n if iter_num > 100:\n end_idx = end_idx * 2\n\n # pick an entry point from the first 30%\n entry_point = random.choice(sorted_nodes[:end_idx])\n # print \"Source \", i\n # print \"candidates: \", sorted_nodes[:end_idx]\n # print \"entry point: \", entry_point\n # print \"all nodes: \", G.nodes()\n\n # pick a random point from the reachables\n reachables = nx.shortest_path(G, entry_point)\n del reachables[entry_point]\n #print \"reachables: \", reachables\n reachables = reachables.keys()\n\n exit_point = random.choice(reachables)\n #print \"exit_point: \", exit_point\n\n if degree_s[i]:\n G.add_edge(s, entry_point, weight=degree_s[i])\n G.add_edge(exit_point, t, weight=degree_s[i])\n else:\n # figure out the out_degree of entry point\n out_degree = np.sum(G[u][v]['weight'] for u,v in G.out_edges(entry_point))\n G.add_edge(s, entry_point, weight=out_degree)\n\n # figure out the int_degree of exit point\n in_degree = np.sum(G[u][v]['weight'] for u,v in G.in_edges(exit_point))\n G.add_edge(exit_point, t, weight=in_degree)\n\n edges = G.edges()\n for u, v in edges:\n par_num = int(G[u][v]['weight'])\n for i in range(par_num):\n self.add_edge(u, v)\n\n # set indices etc\n self.set_sources(srcs)\n self.set_destinations(dsts)\n self.set_indices()\n #print \"number of nodes: \" + str(self.number_of_nodes())\n #print \"number of edges: \" + str(self.number_of_edges())","def __generate_all_shortest_paths(self,cutoff = 10):\n if cutoff < 1:\n cutoff = 10\n self.__logger.info(\"cutoff value must be a positive integer. Set back to default value: 10\")\n\n all_pair_shortest_paths = nx.all_pairs_shortest_path(self.G, cutoff=cutoff)\n for item in all_pair_shortest_paths:\n from_node = item[0]\n paths = item[1]\n for destination,path in paths.items():\n yield (len(path),path)","def ford_fulkerson_algorithm(graph: np.ndarray, source: int, sink: int) -> np.ndarray:\r\n\r\n residual_graph = copy.deepcopy(graph)\r\n row = len(residual_graph)\r\n parent = [-1] * row\r\n max_flow = 0\r\n\r\n if source == sink or sink < 0 or source < 0 or source >= row or sink >= row:\r\n raise WrongInputException('Wrong input source/sink vertice(s)')\r\n\r\n while bfs(residual_graph, row, source, sink, parent):\r\n\r\n path_flow = float(\"Inf\")\r\n s = sink\r\n while s != source:\r\n path_flow = min(path_flow, residual_graph[parent[s]][s])\r\n s = parent[s]\r\n\r\n max_flow += path_flow\r\n\r\n v = sink\r\n while v != source:\r\n u = parent[v]\r\n residual_graph[u][v] -= path_flow\r\n residual_graph[v][u] += path_flow\r\n v = parent[v]\r\n print(\"Max flow: %d\" % max_flow)\r\n\r\n return residual_graph","def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\n demand: float,\n routing: np.ndarray) -> np.ndarray:\n edge_mapping = {edge: i for i, edge in\n enumerate(sorted(self.graph.edges))}\n\n link_utilisation = np.zeros(self.num_edges)\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\n node_flow[flow[0]] = demand\n\n to_explore = [flow[0]]\n while to_explore:\n current_node = to_explore.pop(0)\n current_flow = node_flow[current_node]\n\n # this is the flow destination node so we absorb all flow\n if current_node == flow[1]:\n node_flow[current_node] = 0.0\n continue\n\n # push the flow at this node over all edges\n for edge in self.graph.out_edges(current_node):\n edge_index = edge_mapping[edge]\n ratio = routing[edge_index]\n flow_to_send = ratio * current_flow\n # only send flow if greater than epsilon (so no 'infinite' loops)\n if flow_to_send > 1.e-8:\n node_flow[edge[1]] += ratio * current_flow\n # all important step, update our output\n link_utilisation[edge_index] += ratio * current_flow\n # have updated the dst so add it to the list of things to do\n to_explore.append(edge[1])\n # we've moved all the flow from this node now, so reset back to zero\n node_flow[current_node] = 0.0\n\n return link_utilisation","def run_random_annealing(tsp_file, T, scheme, N_sim, max_chain_length=100000, c=.95):\n # create empty lists for to be stored values\n best_routes, costs, cost_lists = [], [], []\n\n adjacency_matrix = make_matrix(tsp_file)\n\n for _ in range(N_sim):\n # generate random initial route\n x = list(range(len(adjacency_matrix)))\n init_route = random.sample(x,len(x))\n \n # find best route with SA algorithm\n best_route, cost_list = tsp_annealing_random(T, scheme, init_route, adjacency_matrix, max_chain_length, c)\n\n # append all values from simulation to lists\n costs.append(calculate_cost(best_route,adjacency_matrix)[1])\n best_routes.append(best_route)\n cost_lists.append(cost_list)\n\n return best_routes, costs, cost_lists","def stochastic_event_set(\n sources, source_site_filter=filters.source_site_noop_filter):\n for source, s_sites in source_site_filter(sources):\n try:\n for rupture in source.iter_ruptures():\n for i in range(rupture.sample_number_of_occurrences()):\n yield rupture\n except Exception as err:\n etype, err, tb = sys.exc_info()\n msg = 'An error occurred with source id=%s. Error: %s'\n msg %= (source.source_id, str(err))\n raise_(etype, msg, tb)","def sampled_clique(clusters,strategy):\n G = nx.Graph()\n sample = []\n #Sample 'size' nodes from a single cluster\n if strategy == \"rand\":\n size = len(clusters)\n while len(sample) < size:\n cluster = random.choice(clusters)\n if len(cluster) >= size:\n sample = random.sample(cluster,size)\n #Sample 1 choice from each cluster\n elif strategy == \"optim\":\n for _,cluster in clusters.items():\n if len(cluster) > 0:\n sample.append(random.choice(cluster))\n for n1 in sample:\n for n2 in sample:\n if n1 != n2:\n G.add_edge(n1,n2)\n return G","def get_k_shortest_paths(env: RailEnv,\n source_position: Tuple[int, int],\n source_direction: int,\n target_position=Tuple[int, int],\n k: int = 1, debug=False) -> List[Tuple[Waypoint]]:\n\n # P: set of shortest paths from s to t\n # P =empty,\n shortest_paths: List[Tuple[Waypoint]] = []\n\n # countu: number of shortest paths found to node u\n # countu = 0, for all u in V\n count = {(r, c, d): 0 for r in range(env.height) for c in range(env.width) for d in range(4)}\n\n # B is a heap data structure containing paths\n # N.B. use OrderedSet to make result deterministic!\n heap: OrderedSet[Tuple[Waypoint]] = OrderedSet()\n\n # insert path Ps = {s} into B with cost 0\n heap.add((Waypoint(source_position, source_direction),))\n\n # while B is not empty and countt < K:\n while len(heap) > 0 and len(shortest_paths) < k:\n if debug:\n print(\"iteration heap={}, shortest_paths={}\".format(heap, shortest_paths))\n # – let Pu be the shortest cost path in B with cost C\n cost = np.inf\n pu = None\n for path in heap:\n if len(path) < cost:\n pu = path\n cost = len(path)\n u: Waypoint = pu[-1]\n if debug:\n print(\" looking at pu={}\".format(pu))\n\n # – B = B − {Pu }\n heap.remove(pu)\n # – countu = countu + 1\n\n urcd = (*u.position, u.direction)\n count[urcd] += 1\n\n # – if u = t then P = P U {Pu}\n if u.position == target_position:\n if debug:\n print(\" found of length {} {}\".format(len(pu), pu))\n shortest_paths.append(pu)\n\n # – if countu ≤ K then\n # CAVEAT: do not allow for loopy paths\n elif count[urcd] <= k:\n possible_transitions = env.rail.get_transitions(*urcd)\n if debug:\n print(\" looking at neighbors of u={}, transitions are {}\".format(u, possible_transitions))\n # for each vertex v adjacent to u:\n for new_direction in range(4):\n if debug:\n print(\" looking at new_direction={}\".format(new_direction))\n if possible_transitions[new_direction]:\n new_position = get_new_position(u.position, new_direction)\n if debug:\n print(\" looking at neighbor v={}\".format((*new_position, new_direction)))\n\n v = Waypoint(position=new_position, direction=new_direction)\n # CAVEAT: do not allow for loopy paths\n if v in pu:\n continue\n\n # – let Pv be a new path with cost C + w(u, v) formed by concatenating edge (u, v) to path Pu\n pv = pu + (v,)\n # – insert Pv into B\n heap.add(pv)\n\n # return P\n return shortest_paths","def test_heuristic_first_steps(self):\n graph = {n: set(self.deterministic_graph[n]) - set([n])\n for n in self.deterministic_graph}\n deg_heuristic = MinDegreeHeuristic(graph)\n elim_node = deg_heuristic.best_node(graph)\n print(\"Graph {}:\".format(graph))\n steps = []\n\n while elim_node is not None:\n print(\"Removing {}:\".format(elim_node))\n steps.append(elim_node)\n nbrs = graph[elim_node]\n\n for u, v in itertools.permutations(nbrs, 2):\n if v not in graph[u]:\n graph[u].add(v)\n\n for u in graph:\n if elim_node in graph[u]:\n graph[u].remove(elim_node)\n\n del graph[elim_node]\n print(\"Graph {}:\".format(graph))\n elim_node = deg_heuristic.best_node(graph)\n\n # check only the first 5 elements for equality\n assert_equals(steps[:5], [0, 1, 2, 3, 4])","def _compute_flows(paths):\n assert isinstance(paths, list)\n\n # allocate memory\n flows = np.zeros([len(paths), FLAGS.target_height, FLAGS.target_width, 2],\n dtype=np.float32)\n\n # load all images\n pbar = ProgressBar(max_value=len(paths))\n for i in range(len(paths)-1):\n im1 = skimage.io.imread(paths[i])\n im2 = skimage.io.imread(paths[i+1])\n\n im1 = cv2.cvtColor(im1, cv2.COLOR_RGB2GRAY)\n im2 = cv2.cvtColor(im2, cv2.COLOR_RGB2GRAY)\n im1 = skimage.transform.resize(\n im1, [FLAGS.target_height, FLAGS.target_width], preserve_range=True,\n mode='constant', anti_aliasing=True)\n im2 = skimage.transform.resize(\n im2, [FLAGS.target_height, FLAGS.target_width], preserve_range=True,\n mode='constant', anti_aliasing=True)\n flow = cv2.calcOpticalFlowFarneback(\n im1, im2, flow=None, pyr_scale=0.5, levels=3, winsize=15,\n iterations=3, poly_n=5, poly_sigma=1.2, flags=0)\n\n # store images\n flows[i] = flow\n pbar.update(i)\n\n # Replicate the flow for last frame\n flows[-1] = flow\n return flows","def random_partition_graph(groups, p_in, p_out, seed=None):\r\n\r\n if p_in > 1 or p_in < 0:\r\n raise errorhandler.ErrorHandler(\"p_in must be in [0,1]\")\r\n\r\n if p_out > 1 or p_out < 0:\r\n raise errorhandler.ErrorHandler(\"p_out must be in [0,1]\")\r\n\r\n size = sum(groups)\r\n g = graph.Graph(size, is_partition=True)\r\n\r\n next_group = {}\r\n start = 0\r\n group_index = 0\r\n for n in groups: # connect nodes inside a group\r\n edges = ((u + start, v + start) for u, v in fast_random_graph(n, p_in).edges)\r\n g.add_edges(edges)\r\n g.partition.append(set(range(start, start+n)))\r\n next_group.update(dict.fromkeys(range(start, start + n), start + n))\r\n group_index += 1\r\n start += n\r\n\r\n # connect nodes between groups\r\n if p_out == 0:\r\n return g\r\n if p_out == 1:\r\n for n in next_group:\r\n targets = range(next_group[n], len(g))\r\n g.add_edges(zip([n] * len(targets), targets))\r\n return g\r\n\r\n # using method similar to fast_random_graph\r\n lp = math.log(1.0 - p_out)\r\n n = len(g)\r\n\r\n for u in range(n - 1):\r\n v = next_group[u]\r\n while v < n:\r\n lr = math.log(1.0 - random.random())\r\n v += int(lr / lp)\r\n if v < n:\r\n g.add_edge(u, v)\r\n v += 1\r\n\r\n return g","def get_routing_solution(self):\n G = self.base_digraph\n s1 = self.sources[0]\n s2 = self.sources[1]\n t1 = self.destinations[0]\n t2 = self.destinations[1]\n\n try:\n m = Model('routing')\n m.setParam('OutputFlag', False)\n\n # variables,\n # We have one variable per edge per session\n # e is the dict of dict for the variables\n e = {}\n r = {}\n for i in [1,2]:\n e[i] = {}\n r[i] = m.addVar()\n for u,v in G.edges():\n e[i][u,v] = m.addVar(lb=0)\n\n m.update()\n\n obj = quicksum(r.values())\n m.setObjective(obj, GRB.MAXIMIZE)\n\n # constraints\n # 1. conservations of flow at all intermediate nodes\n # 2. capacity constraints for each edge\n\n for u,v in G.edges():\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\n\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\n\n for n in G.nodes():\n if n not in [s1, s2, t1, t2]:\n for i in [1, 2]:\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\n m.addConstr(inflow == outflow)\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n for u, v in G.edges():\n G[u][v]['Routing'] = {}\n G[u][v]['Routing'][1] = e[1][u,v].x\n G[u][v]['Routing'][2] = e[2][u,v].x\n return (m.objVal, r[1].x, r[2].x)\n else:\n # something went wrong...err...\n print \"Something was wrong, no optimal solution obtained\"\n return None, None, None\n\n except GurobiError:\n Print ('Error Report from Gurobi')","def shuffle(self) -> NoReturn:\n for edge_type in self.edge_types:\n for edge_class in range(self.edge_types[edge_type]):\n self.train_edges[edge_type][edge_class] = np.random.permutation(\n self.train_edges[edge_type][edge_class])\n\n self.freebatch_edge_types = {edge_type: list(range(edge_class))\n for edge_type, edge_class in self.edge_types.items()}\n self.batch_num = {edge_type: [0] * edge_class for edge_type, edge_class in\n self.edge_types.items()}\n self.took_all_edges = {edge_type: False for edge_type in self.edge_types}\n self.iter = 0","def get_random_depth_sample(n=8, depths=list(range(2,26,2)), num_samples=100):\n\n def get_states(start):\n frontier = [start]\n frontier_set = {start}\n explored = set()\n\n states = [False for _ in range(len(depths))]\n while not all(states):\n node = frontier.pop(0)\n frontier_set.remove(node)\n explored.add(node)\n\n children = node.get_children()\n\n # It's necessary to shuffle children to get a truly random sample; otherwise, the first child (always\n # produced from the parent by the same action) produced at a certain depth will always be selected,\n # and children produced by other actions will never be selected\n shuffle(children)\n\n for child in children:\n if child not in frontier_set and child not in explored:\n frontier_set.add(child)\n frontier.append(child)\n child.path_cost = node.path_cost+1\n index = depths.index(child.path_cost) if child.path_cost in depths else None\n if index is not None and not states[index]:\n states[index] = {'start': start.sequence, 'end': child.sequence}\n\n return states\n\n depth_sample = [[] for depth in range(len(depths))]\n\n for _ in range(num_samples):\n start = list(range(1,n+2))\n shuffle(start)\n start = PuzzleState(start, path_cost=0)\n\n states = get_states(start)\n print('\\rSet ' + str(_+1) + ' of ' + str(num_samples) + ' complete', end='', flush=True)\n list(map(list.append, depth_sample, states))\n\n return depth_sample","def tsp_annealing_random(T, scheme, route, adjacency_matrix, max_chain_length,c):\n best = route.copy()\n chains = 0\n cost_list = []\n T_0 = T\n T_list = []\n \n while T > 0:\n # Sample city from route\n temp = route.copy()\n index1, index2 = np.random.randint(1,len(best)-1,size=2)\n\n sd, cost0 = calculate_cost(route,adjacency_matrix)\n cost_list.append(cost0)\n\n temp[index1:index2] = temp[index2-1:index1-1:-1]\n _, cost1 = calculate_cost(temp,adjacency_matrix)\n\n chains += 1\n T_list.append(T)\n\n # Adjust temperature\n if scheme == \"exp\":\n T = T*c\n if scheme == \"log\":\n alpha = 50\n T = T_0/(1+alpha*np.log(1+chains))\n if scheme == \"std\":\n delta = .1\n T = T / (1 + ((np.log(1+delta)* T) / (3 * sd)))\n if scheme == \"quad\":\n alpha = 1\n T = T_0/(1+alpha*chains**2)\n\n # Metropolis step \n if cost0 > cost1:\n route = temp.copy()\n else:\n U = rs.uniform()\n if U < np.exp((cost0-cost1)/T):\n route = temp.copy()\n\n best = route.copy()\n if chains > max_chain_length:\n return best, cost_list\n return best, cost_list","def _dfs(\n self, kg: KG, entity: Vertex, is_reverse: bool = False\n ) -> List[Walk]:\n self.sampler.visited = set()\n walks: List[Walk] = []\n assert self.max_walks is not None\n\n rng = np.random.RandomState(self.random_state)\n\n while len(walks) < self.max_walks:\n sub_walk: Walk = (entity,)\n d = 1\n while d // 2 < self.max_depth:\n pred_obj = self.sampler.sample_hop(\n kg, sub_walk, d // 2 == self.max_depth - 1, is_reverse\n )\n if pred_obj is None:\n break\n\n if is_reverse:\n if (\n pred_obj[0] in self.communities\n and rng.random() < self.hop_prob\n ):\n community_nodes = self.labels_per_community[\n self.communities[pred_obj[0]]\n ]\n sub_walk = (\n pred_obj[1],\n rng.choice(community_nodes),\n ) + sub_walk\n else:\n sub_walk = (pred_obj[1], pred_obj[0]) + sub_walk\n else:\n if (\n pred_obj[1] in self.communities\n and rng.random() < self.hop_prob\n ):\n community_nodes = self.labels_per_community[\n self.communities[pred_obj[1]]\n ]\n sub_walk += (\n pred_obj[0],\n rng.choice(community_nodes),\n )\n else:\n sub_walk += (pred_obj[0], pred_obj[1])\n d = len(sub_walk) - 1\n walks.append(sub_walk)\n return list(walks)","def update_flow(self):\n N = len(self.vertices)\n _vertices = self.vertices+['_source', '_sink']\n s, t = _vertices.index('_source'), _vertices.index('_sink')\n cost, capacity = dok_matrix((N+2, N+2)), dok_matrix((N+2, N+2))\n\n cost[:N, :N] = self.cost\n capacity[:N, :N] = self.upper_bound-self.lower_bound\n # _source to main vertices\n l_in = self.lower_bound.toarray().sum(axis=0)\n us, = l_in.nonzero()\n for u in us:\n capacity[s, u] = l_in[u]\n # main vertices to _sink\n l_out = self.lower_bound.toarray().sum(axis=1)\n us, = l_out.nonzero()\n for u in us:\n capacity[u, t] = l_out[u]\n # sink to source\n infinite_flow = self.upper_bound.toarray().sum()\n capacity[_vertices.index('sink'), _vertices.index('source')] = infinite_flow\n\n # get a feasible flow on original graph by finding the max flow on\n # auxiliary graph\n aux_fg = FlowGraph(_vertices, cost, capacity, True)\n aux_fg.FordFulkerson()\n assert aux_fg.residual[s].toarray().sum()==0, 'feasible flow within bounds not found'\n\n self.residual = aux_fg.residual[:N, :N]\n s, t = self.vertices.index('source'), self.vertices.index('sink')\n self.residual[s, t] = 0\n self.residual[t, s] = 0\n\n self.FordFulkerson()","def test_heuristic_first_steps(self):\n graph = {n: set(self.deterministic_graph[n]) - set([n])\n for n in self.deterministic_graph}\n print(\"Graph {}:\".format(graph))\n elim_node = min_fill_in_heuristic(graph)\n steps = []\n\n while elim_node is not None:\n print(\"Removing {}:\".format(elim_node))\n steps.append(elim_node)\n nbrs = graph[elim_node]\n\n for u, v in itertools.permutations(nbrs, 2):\n if v not in graph[u]:\n graph[u].add(v)\n\n for u in graph:\n if elim_node in graph[u]:\n graph[u].remove(elim_node)\n\n del graph[elim_node]\n print(\"Graph {}:\".format(graph))\n elim_node = min_fill_in_heuristic(graph)\n\n # check only the first 2 elements for equality\n assert_equals(steps[:2], [6, 5])","def randnet(G):\n\t\n\t#initializationo of the lists\n\telst = G.get_edgelist()\n\tclst = G.es['color'][:]\n\tcdic = {}\n\tfor i,c in enumerate(clst):\n\t\tcdic[c]=i\n\tlst1 = [[]]*len(key)\n\tfor i,e in enumerate(elst):\n\t\tlst1[cdic[clst[i]]].append([e[0],e[1]])\n\t\t\n\t#randomization procedure\n\tfor i in range(random.randrange(100,200)):\n\t\tcid = cdic[random.choice(clst)] #random choice weighted by the frequency of each color\n\t\te1id = random.randrange(0,len(lst1[cid])) #random choice of edge with that color\n\t\te2id = random.randrange(0,len(lst1[cid]))\n\t\textop = random.randrange(0,2)#random choice of top/bottom\n\t\tttemp = lst1[cid][e1id][extop]\n\t\tlst1[cid][e1id][extop] = lst1[cid][e2id][extop]\n\t\tlst1[cid][e2id][extop] = ttemp\n\t\n\tcoutlst = []\n\teoutlst\t= []\n\tfor i in range(len(lst1)):\n\t\tc = clst[i]\n\t\tfor e in lst1[i]:\n\t\t\tcoutlst.append(c)\n\t\t\teoutlst.append((e[0],e[1]))\n\n\treturn [eoutlst,coutlst]","def get_weight_from_minflow(self):\n start_nodes = []\n end_nodes = []\n capacities = []\n unit_costs = []\n A = 0\n s_prime = self.sink() + 1\n t_prime = self.sink() + 2\n x = self.sink() + 3\n # for every edge in the graph, add edge to mincost flow instance with\n # infinite capacity and cost 1\n # also add backwards edge\n for arc in self.arc_info.keys():\n # forward edge\n start_nodes.append(self.arc_info[arc][\"start\"])\n end_nodes.append(self.arc_info[arc][\"destin\"])\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"start\"],\n self.arc_info[arc][\"destin\"]))\n # backward edge\n start_nodes.append(self.arc_info[arc][\"destin\"])\n end_nodes.append(self.arc_info[arc][\"start\"])\n capacities.append(int(self.arc_info[arc][\"weight\"])) # no negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"destin\"],\n self.arc_info[arc][\"start\"]))\n # add (x,s) and (t,x) edges with same cap, cost as above\n in_weight_x = 0\n for in_arc in self.in_arcs_lists[self.sink()]:\n in_weight_x += self.arc_info[in_arc][\"weight\"]\n out_weight_x = 0\n for out_arc in self.out_arcs_lists[self.source()]:\n out_weight_x += self.arc_info[out_arc][\"weight\"]\n # (x,s)\n start_nodes.append(x)\n end_nodes.append(self.source())\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.source()))\n # backward\n start_nodes.append(self.source())\n end_nodes.append(x)\n capacities.append(int(out_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.source(),\n x))\n # (t,x)\n start_nodes.append(self.sink())\n end_nodes.append(x)\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.sink(),\n x))\n # backward\n start_nodes.append(x)\n end_nodes.append(self.sink())\n capacities.append(int(in_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.sink()))\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\n # and cost 0.\n for v in self:\n # process internal verts only, since we assume source and sink have\n # no in and out edges respectively\n if v != self.source() and v != self.sink():\n # compute a-exc(v)\n in_weight = 0\n for in_arc in self.in_arcs_lists[v]:\n in_weight += self.arc_info[in_arc][\"weight\"]\n out_weight = 0\n for out_arc in self.out_arcs_lists[v]:\n out_weight += self.arc_info[out_arc][\"weight\"]\n a_exc = out_weight - in_weight\n if a_exc < 0:\n # add edge (s', v)\n start_nodes.append(s_prime)\n end_nodes.append(v)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n v,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (v, t')\n start_nodes.append(v)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n v,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # process x node\n a_exc = out_weight_x - in_weight_x\n if a_exc < 0:\n # add edge (s', x)\n start_nodes.append(s_prime)\n end_nodes.append(x)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n x,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (x, t')\n start_nodes.append(x)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n x,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # we must send flow of A from s_prime to t_prime\n supplies = [0]*(len(self) + 3)\n supplies[s_prime] = int(A)\n supplies[t_prime] = int(-A)\n # Instantiate a SimpleMinCostFlow solver.\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\n # Add each arc.\n for i in range(len(start_nodes)):\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\n end_nodes[i], capacities[i], unit_costs[i])\n # Add node supplies\n for i in range(0, len(supplies)):\n min_cost_flow.SetNodeSupply(i, supplies[i])\n # Find the minimum cost flow between node s' and t'.\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\n print('Minimum cost:', min_cost_flow.OptimalCost())\n print('')\n print(' Arc Flow / Capacity Cost')\n for i in range(min_cost_flow.NumArcs()):\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\n print('%1s -> %1s %3s / %3s %3s' % (\n min_cost_flow.Tail(i),\n min_cost_flow.Head(i),\n min_cost_flow.Flow(i),\n min_cost_flow.Capacity(i),\n cost))\n # update arcs\n start = min_cost_flow.Tail(i)\n destin = min_cost_flow.Head(i)\n if start != s_prime and \\\n start != t_prime and \\\n start != x and \\\n destin != s_prime and \\\n destin != t_prime and \\\n destin != x:\n # if forward, increase flow. otherwise decrease.\n print(\"Processing edge ({}, {})\".format(start, destin))\n if start < destin:\n sup_flow = min_cost_flow.Flow(i)\n else:\n sup_flow = -min_cost_flow.Flow(i)\n temp_start = start\n start = destin\n destin = temp_start\n print(\"Has become ({}, {}) with sup {}\".format(start,\n destin,\n sup_flow))\n arc = self.get_arc(start, destin)\n if (sup_flow != 0) or (\"lower_bound\" not in \\\n self.arc_info[arc].keys()):\n print(\"We should add this\")\n old_flow = self.arc_info[arc][\"weight\"]\n new_flow = old_flow + sup_flow\n self.arc_info[arc][\"weight\"] = int(new_flow)\n print(\"Edge ({},{}) weight is changed from {} to {}\".format(\n start,\n destin,\n old_flow,\n new_flow))\n else:\n print('There was an issue with the min cost flow input.')\n #self.check_conservation_of_flow() # check that solution is valid","def get_flows(self, num_flows_per_entry):\n flows = []\n for tenant in self._tenants:\n for contract in tenant.get_children(only_class=Contract):\n providing_epgs = contract.get_all_providing_epgs()\n consuming_epgs = contract.get_all_consuming_epgs()\n for providing_epg in providing_epgs:\n vlan_ifs = providing_epg.get_all_attached(L2Interface)\n if len(vlan_ifs):\n providing_vlan = vlan_ifs[0].encap_id\n phys_ifs = vlan_ifs[0].get_all_attached(Interface)\n if len(phys_ifs):\n providing_phys_if = phys_ifs[0].name\n for consuming_epg in consuming_epgs:\n vlan_ifs = consuming_epg.get_all_attached(L2Interface)\n if len(vlan_ifs):\n consuming_vlan = vlan_ifs[0].encap_id\n phys_ifs = vlan_ifs[0].get_all_attached(Interface)\n if len(phys_ifs):\n consuming_phys_if = phys_ifs[0].name\n if providing_vlan == consuming_vlan and providing_phys_if == consuming_phys_if:\n # Skip this case since traffic would be switched outside fabric\n continue\n for filter_entry in contract.get_all_filter_entries():\n for i in range(0, num_flows_per_entry):\n flow = Flow()\n flow.ethertype = filter_entry.etherT\n if flow.ethertype == 'arp':\n flow.arp_opcode = filter_entry.arpOpc\n flow.populate_random_ip_addresses()\n elif flow.ethertype == 'ip':\n flow.populate_random_ip_addresses()\n flow.proto = filter_entry.prot\n if flow.proto == '6' or flow.proto == '17':\n dFromPort = int(filter_entry.dFromPort)\n dToPort = int(filter_entry.dToPort)\n sFromPort = int(filter_entry.sFromPort)\n sToPort = int(filter_entry.sToPort)\n if dFromPort == 0:\n dFromPort = 1\n dToPort += 1\n if sFromPort == 0:\n sFromPort = 1\n sToPort += 1\n if dToPort > 65534:\n dToPort = 65534\n if sToPort > 65534:\n sToPort = 65534\n flow.dport = str(random_number(dFromPort,\n dToPort))\n flow.sport = str(random_number(sFromPort,\n sToPort))\n if flow.proto == '6':\n flow.tcp_rules = filter_entry.tcpRules\n flow.svlan = providing_vlan\n flow.dvlan = consuming_vlan\n flow.src_intf = providing_phys_if\n flow.dst_intf = consuming_phys_if\n\n # Is the flow expected to succeed ?\n flow.expected_action = 'drop'\n providing_bd = providing_epg.get_bd()\n consuming_bd = consuming_epg.get_bd()\n if providing_bd and consuming_bd:\n if providing_bd == consuming_bd:\n if providing_bd.get_context() == consuming_bd.get_context():\n flow.expected_action = 'permit'\n flow.populate_random_mac_addresses()\n flows.append(flow)\n return flows","def test_sources():\n g = Graph(from_list=[\n (1, 3, 1),\n (2, 4, 1),\n (2, 5, 1),\n (3, 5, 1),\n (4, 6, 1),\n (5, 6, 1),\n ])\n g.add_node(7)\n s = g.sources(5)\n e = {1, 2, 3}\n assert s == e\n\n s2 = g.sources(1)\n e2 = set()\n assert s2 == e2, s2\n\n s3 = g.sources(6)\n e3 = {1, 2, 3, 4, 5}\n assert s3 == e3\n\n s4 = g.sources(7)\n e4 = set()\n assert s4 == e4","def max_flow(self, source, sink):\n\n path = self.valid_path(source, sink, [])\n\n while path:\n # get the maximum possible flow that can be taken from this path:\n max_flow = min([edge.capacity for edge in path])\n for edge in path:\n self.edges[edge] += max_flow\n path = self.valid_path(source, sink, [])\n\n # Compute all the flows from the neighbors of source:\n return sum([self.edges[edge] for edge in self.adjacents[source]])","def gen_task_sets_fairgen(nsets):\n start = time()\n eval_task_sets = []\n for util in utils:\n task_sets = []\n for i in range(nsets):\n ts = synth.mc_fairgen(set_id=i, u_lo=util, implicit_deadlines=True)\n synth.synth_c_pmf(ts)\n synth.set_fixed_priorities(ts)\n task_sets.append(ts)\n eval_task_sets.append(task_sets)\n stop = time()\n print('Task Set Generation MC-Fairgen: %.3fs' % (stop - start))\n pickle.dump(eval_task_sets, open(task_sets_path + 'task_sets_fairgen', 'wb'))","def run_destination_reduction(self):\n s = self.sources\n t = self.destinations\n\n # get the union set of source edges\n s_edges = [self.out_edges(x) for x in s]\n s_edges_idx = [set(self.get_edges_indices(src)) for src in s_edges]\n S = set.union(*s_edges_idx)\n\n # now starting from the sources\n T_curr = [set(self.in_edges(x)) for x in t]\n T_curr_idx = [set(self.get_edges_indices(x)) for x in T_curr]\n T_union = set.union(*[set(x) for x in T_curr])\n T_union_idx = set.union(*T_curr_idx)\n self.dst_evolution_rec = [T_curr_idx]\n\n while not T_union_idx.issubset(S):\n # get the edges out of the max-ordered node\n tail_nodes = set([x[0] for x in T_union])\n tail_nodes = tail_nodes - set(s)\n v = max(tail_nodes, key=lambda p: self.node[p]['index'])\n\n E = set([edge for edge in T_union if edge[0] == v])\n E_curr = [x.intersection(E) for x in T_curr]\n\n T_next = []\n Uv = self.in_edges(v)\n for (Ex, Tx) in zip(E_curr, T_curr):\n if Ex:\n T_next.append((Tx - Ex).union(Uv))\n else:\n T_next.append(Tx)\n\n T_curr = T_next\n T_curr_idx = [set(self.get_edges_indices(x)) for x in T_curr]\n self.dst_evolution_rec.append(T_curr_idx)\n\n T_union = set.union(*[set(x) for x in T_curr])\n T_union_idx = set.union(*T_curr_idx)","def objective(graph, flows):\n\n G = graph.copy()\n rules = {}\n flows.sort(key=lambda a: a[1], reverse=True)\n\n for flow,demand in flows:\n src = get_host_from_ip(G, flow.nw_src)\n dst = get_host_from_ip(G, flow.nw_dst)\n\n if not (src and dst):\n continue\n if not (src in G.nodes() and dst in G.nodes()):\n continue\n\n path = widest_path(G, src, dst)\n\n hops = []\n for a,b in pairwise(path):\n hops.append(Hop(dpid=int(a[1:]), port=G.edge[a][b]['port']))\n G.edge[a][b]['capacity'] -= demand\n G.edge[b][a]['capacity'] -= demand\n\n rules[flow] = hops\n\n return rules","def _select_destination(self):\n # Ideally this should do something clever based on the start location\n # ie known trips. But for now, it will pick randomly!\n station_dict = self.network.station_dict\n\n stations = list(station_dict.keys())\n #stations = [x for x in stations if isinstance(x, int) or x.startswith(\"801\")]\n #stations = [x for x in stations if isinstance(x, int) or x.startswith(\"80139\")]\n weights = [station_dict[x].in_popularity for x in stations]\n\n # pick using the given weight distributions\n self.dest = random.choices(stations, weights=weights)[0]\n\n return","def multipleTravellingSalesmen2(self, iterations=None):\n if not iterations:\n iterations = self.mTSPIterations\n\n paths, self.totaldistanceMTSP = self.greedyMultiplePaths(self.ships)\n\n # Run single travelling salesman on each of the ships\n paths = [self.singleTravellingSalesman2(path, iterations=5000) for path in paths]\n\n # IF TWO OR MORE SHIPS!!!\n # Point exchange between ships and rerun tsp on each ship\n if len(self.ships) > 1:\n for _ in range(iterations):\n twopathindices = random.sample(xrange(len(paths)), 2)\n if min([len(path) for path in paths]) > 1:\n newtwopaths = self.swapTwoPointsBetweenPaths([paths[index] for index in twopathindices])\n newtwopaths = [self.singleTravellingSalesman2(path, iterations=100) for path in newtwopaths]\n if self.totalPathDistance(newtwopaths) < self.totalPathDistance([paths[index] for index in twopathindices]):\n for i, index in enumerate(twopathindices):\n paths[index] = newtwopaths[i]\n\n return [path[::-1] for path in paths]\n\n # Might be a simple tsp whereby the new points search for the twp closest points and\n # inserts between them on the path","def __generate_random_nodes(self,k=3):\n if k < 3:\n k = 3\n\n k = min(k,len(self.G.nodes()))\n self.__logger.info(\"RANDOM_NODES: try to generate a set of {} nodes sampled with uniform distribution\".format(k))\n \n return random.sample(self.G.nodes(),k)","def __dynamicThroughput( self, sourceSEs, destSEs ):\n res = self.__getTimeToStart()\n if not res['OK']:\n gLogger.error( res['Message'] )\n return {}\n channelInfo = res['Value']\n\n timeToSite = {} # Maintains time to site including previous hops\n siteAncestor = {} # Maintains the ancestor channel for a site\n tree = {} # Maintains replication tree\n while len( destSEs ) > 0:\n minTotalTimeToStart = float( \"inf\" )\n candidateChannels = []\n sourceActiveSEs = self.__getActiveSEs( sourceSEs )\n for destSE in destSEs:\n destSites = self.__getChannelSitesForSE( destSE )\n localTransfer = False\n for destSite in destSites:\n if localTransfer: break\n for sourceSE in sourceActiveSEs:\n if localTransfer: break\n sourceSites = self.__getChannelSitesForSE( sourceSE )\n for sourceSite in sourceSites:\n if localTransfer: break\n channelName = '%s-%s' % ( sourceSite, destSite )\n if channelInfo.has_key( channelName ):\n channelID = channelInfo[channelName]['ChannelID']\n if tree.has_key( channelID ):\n continue\n channelTimeToStart = channelInfo[channelName]['TimeToStart']\n if timeToSite.has_key( sourceSE ):\n totalTimeToStart = timeToSite[sourceSE] + channelTimeToStart + self.sigma\n else:\n totalTimeToStart = channelTimeToStart\n #print '%s-%s %s %s' % (sourceSE,destSE,channelTimeToStart,totalTimeToStart)\n localTransfer = ( sourceSite == destSite )\n if localTransfer or totalTimeToStart < minTotalTimeToStart:\n minTotalTimeToStart = totalTimeToStart\n selectedPathTimeToStart = totalTimeToStart\n candidateChannels = [( sourceSE, destSE, channelID )]\n elif totalTimeToStart == minTotalTimeToStart:\n candidateChannels.append( ( sourceSE, destSE, channelID ) )\n\n #minTotalTimeToStart = totalTimeToStart\n #selectedPathTimeToStart = totalTimeToStart\n #selectedSourceSE = sourceSE\n #selectedDestSE = destSE\n #selectedChannelID = channelID\n else:\n errStr = 'StrategyHandler.__dynamicThroughput: Channel not defined'\n gLogger.warn( errStr, channelName )\n\n #print 'Selected %s \\n' % selectedPathTimeToStart\n\n random.shuffle( candidateChannels )\n selectedSourceSE, selectedDestSE, selectedChannelID = candidateChannels[0]\n timeToSite[selectedDestSE] = selectedPathTimeToStart\n siteAncestor[selectedDestSE] = selectedChannelID\n\n if siteAncestor.has_key( selectedSourceSE ):\n waitingChannel = siteAncestor[selectedSourceSE]\n else:\n waitingChannel = False\n tree[selectedChannelID] = {}\n tree[selectedChannelID]['Ancestor'] = waitingChannel\n tree[selectedChannelID]['SourceSE'] = selectedSourceSE\n tree[selectedChannelID]['DestSE'] = selectedDestSE\n tree[selectedChannelID]['Strategy'] = 'DynamicThroughput'\n sourceSEs.append( selectedDestSE )\n destSEs.remove( selectedDestSE )\n return tree","def shuffle(self):\n for edge_type in self.edge_types:\n for k in range(self.edge_types[edge_type]):\n self.train_edges[edge_type][k] = np.random.permutation(self.train_edges[edge_type][k])\n self.batch_num[self.edge_type2idx[edge_type[0], edge_type[1], k]] = 0\n self.current_edge_type_idx = 0\n self.freebatch_edge_types = list(range(self.num_edge_types))\n self.freebatch_edge_types.remove(self.edge_type2idx[0, 0, 0])\n self.freebatch_edge_types.remove(self.edge_type2idx[0, 1, 0])\n self.freebatch_edge_types.remove(self.edge_type2idx[1, 0, 0])\n self.iter = 0","def randomNetwork(self, numVertices, numEdges, capacityRange):\r\n for _ in range(numEdges):\r\n fromVertex, toVertex = None, None\r\n while fromVertex == toVertex or (fromVertex, toVertex) in self.capacity:\r\n fromVertex = randint(1, numVertices)\r\n toVertex = randint(1, numVertices)\r\n capacity = randint(1, capacityRange) \r\n self.addEdge(fromVertex, toVertex, capacity)","def configuration_model(g, kmin, kmax, size, c, offset):\n # Makes sure that networks have an even number of half-edges, since\n # the number of half-edges prepared for linking can be uneven.\n its = inverse_transform_sampling(g, kmin, kmax, size, offset)\n sum_its = sum(its)\n while sum_its % 2 != c % 2:\n its = inverse_transform_sampling(g, kmin, kmax, size, offset)\n sum_its = sum(its)\n\n # Brings the dist. seq. into the half-edge form,\n # e.g. [1,2,3] -> [0,1,1,2,2,2]\n seq = []\n k = 0\n for i in range(size):\n for j in range(k, k + its[i]):\n seq += [i]\n k += 1\n\n # Edges that link to other modules\n c_node = np.random.choice(seq, size=c, replace=False)\n for i in range(c):\n seq.remove(c_node[i])\n \n # Connects the half-edges randomly among each other\n np.random.shuffle(seq)\n links = np.sort(np.reshape(seq, (int(len(seq)/2), 2)))\n links = links.tolist()\n \n # Separates the unique and the multi/self links.\n # The list links is left with multi and self links.\n links_unique = []\n k = 0\n while k < len(links):\n if links[k][0] != links[k][1] and links[k] not in links_unique:\n links_unique.append(links.pop(k))\n else:\n k += 1\n \n # Rewires the multi/self links\n for multi in links:\n r1 = random.randint(0, len(links_unique)-1)\n r2 = random.randint(0, 1)\n r3 = random.randint(0, 1)\n links_unique[r1][r2], multi[r3] = multi[r3], links_unique[r1][r2]\n \n network = gt.Graph(directed=False)\n network.add_edge_list(links_unique)\n network.add_edge_list(links)\n\n gt.stats.remove_parallel_edges(network)\n gt.stats.remove_self_loops(network)\n \n return network, c_node","def possible(self):\n return [tuple(path) for path in nx.all_shortest_paths(self._gpm.Graph, source=self.source, target=self.target)]","def _ism_get_mirror_sources(source, receiver, walls, order_threshold, mirrors_threshold):\n logger.info(\"_ism_get_mirror_sources: Determining mirror sources.\")\n model = ism.Model(walls=walls, source=source, receiver=receiver, max_order=order_threshold)\n mirrors = model.determine(strongest=mirrors_threshold)\n yield from mirrors","def connecting_graph(self, solution_graph, weight='cost', ignore_sources=False):\n debut = time.time()\n self.logger.info('start connecting graph')\n\n # we need an undirected graph\n undirected_solution_graph = solution_graph.to_undirected()\n\n if self.old_network_graph is not None and self.modify_old_network:\n undirected_solution_graph = nx.compose(nx.MultiGraph(self.old_network_graph), undirected_solution_graph)\n\n # if already connected\n if nx.is_connected(undirected_solution_graph) == True:\n self.logger.info(\"the solution graph is already connected\")\n return []\n\n # Computing the minimum sources in each component and all junction nodes in the solution graph\n nodetype = nx.get_node_attributes(undirected_solution_graph, config.NODE_TYPE_KEY)\n list_sources = [node for node in nodetype if nodetype[node] == config.SUPPLY_NODE_TYPE]\n\n # 1. Search of all connected subgraphs\n if not ignore_sources:\n reduced_list_sources = []\n while len(list_sources) > 0:\n source, is_isolated = list_sources.pop(0), True\n for i in range(len(list_sources)):\n is_isolated = is_isolated and not (nx.has_path(undirected_solution_graph, source, list_sources[i]))\n if is_isolated:\n reduced_list_sources.append(source)\n else:\n reduced_list_sources = [list(n)[0] for n in nx.connected_components(undirected_solution_graph)]\n\n # 2. Creation of all convex hulls for each source in reduced_list_sources\n hulls = {}\n for source in reduced_list_sources:\n coord_compo = {}\n nodes_connecting_source = nx.node_connected_component(undirected_solution_graph, source)\n for node in nodes_connecting_source:\n xy = tuple(self.optimization_graph.get_node_coordinates(node))\n coord_compo[xy] = node\n if len(coord_compo) > 2:\n convexhull = ConvexHull(list(coord_compo.keys())).points\n else:\n convexhull = list(coord_compo.keys())\n hulls[source] = [coord_compo[tuple(coord)] for coord in convexhull]\n\n # 3. Create list of possible list_edges_to_add\n list_edges_to_add = {} # list of {(S1, S2):(length_of_SP, edges_to_add)}\n\n for S1, S2 in combinations(reduced_list_sources, 2):\n\n # change weight of edges\n for i in range(len(hulls[S1])-1):\n u,v = hulls[S1][i], hulls[S1][i+1]\n self.optimization_graph.add_edge(u,v,key=-1,weight=0)\n self.optimization_graph.add_edge(hulls[S1][-1],hulls[S1][0],key=-1,weight=0)\n for i in range(len(hulls[S2])-1):\n u,v = hulls[S2][i], hulls[S2][i+1]\n self.optimization_graph.add_edge(u,v,key=-1,weight=0)\n self.optimization_graph.add_edge(hulls[S2][-1],hulls[S2][0],key=-1,weight=0)\n\n # find the shortest path\n source, target = hulls[S1][0], hulls[S2][0] # it's a choice to take 0, but no matter\n try:\n length, path = nx.single_source_dijkstra(self.optimization_graph, source, target=target, weight=weight)\n except nx.NetworkXNoPath:\n self.logger.info(\"Source \" + str(S1) + \" and source \" + str(S2) + \" can't be connected\")\n return []\n list_weights = nx.get_edge_attributes(self.optimization_graph, weight)\n\n # edges to add to connect S1 and S2\n edges_to_add = []\n for i in range(len(path) - 1):\n u, v = path[i], path[i + 1]\n # if the edge between (u,v) is not artificial, we add it\n if list_weights.get((u, v, -1), None) != 0 and list_weights.get((u, v, 0), None) is not None:\n edges_to_add.append((u, v, 0))\n if list_weights.get((v, u, -1), None) != 0 and list_weights.get((v, u, 0), None) is not None:\n edges_to_add.append((v, u, 0))\n list_edges_to_add[(S1, S2)] = (length, edges_to_add)\n\n # change weight of edges\n for i in range(len(hulls[S1])-1):\n u,v = hulls[S1][i], hulls[S1][i+1]\n self.optimization_graph.remove_edge(u,v,key=-1)\n self.optimization_graph.remove_edge(hulls[S1][-1],hulls[S1][0],key=-1)\n for i in range(len(hulls[S2])-1):\n u,v = hulls[S2][i], hulls[S2][i+1]\n self.optimization_graph.remove_edge(u,v,key=-1)\n self.optimization_graph.remove_edge(hulls[S2][-1],hulls[S2][0],key=-1)\n\n\n # 4. choice of best edges to add (Kruskal)\n G = nx.Graph()\n for (S1, S2) in list_edges_to_add:\n (length, _) = list_edges_to_add[(S1, S2)]\n if not G.has_node(S1):\n G.add_node(S1)\n if not G.has_node(S2):\n G.add_node(S2)\n G.add_edge(S1, S2, weight=length)\n\n reduced_list_edges_to_add = set()\n T = nx.minimum_spanning_tree(G)\n for u, v in T.edges:\n if (u, v) in list_edges_to_add:\n reduced_list_edges_to_add = reduced_list_edges_to_add.union(set(list_edges_to_add[(u, v)][1]))\n if (v, u) in list_edges_to_add:\n reduced_list_edges_to_add = reduced_list_edges_to_add.union(set(list_edges_to_add[(v, u)][1]))\n\n self.logger.info('end connecting graph in ' + str(time.time() - debut) + ' s')\n return list(reduced_list_edges_to_add)","def _measure(d, sources, target, niter=25, bound=None):\n uniques = {}\n for source in sources:\n others = list(sources)\n others.remove(source)\n others = list(flatten(others))\n uniques[source] = one_way_skar(d, source, target, others)\n return uniques","def find_unique_paths(self, source: str, target: str, number: int = 3) -> List[Tuple[List[str], float]]:\n assert self.graph_handler\n counter = 0\n path_tuple_list = list()\n # # # Initialise iterator over shortest simple paths if it is either not set or source/target do not match\n if not self._use_old_iterator or \\\n self._unique_iterator_memory is None or \\\n self._unique_iterator_memory[0][0][0] != source or \\\n self._unique_iterator_memory[0][0][-1] != target:\n path_iterator = iter(nx.shortest_simple_paths(self.graph_handler.graph, source, target, weight=\"weight\"))\n # # # Find first path and its cost\n old_path = next(path_iterator)\n old_path_cost = nx.path_weight(self.graph_handler.graph, old_path, weight=\"weight\")\n else:\n path_iterator = self._unique_iterator_memory[1]\n old_path = self._unique_iterator_memory[0][0]\n old_path_cost = self._unique_iterator_memory[0][1]\n\n while counter < number:\n same_cost = True\n tmp_path_list: List[List[str]] = list()\n # # # Collect all paths with same cost\n # TODO: Parameter for max tmp paths\n n_max_collected_paths = 10\n while same_cost and len(tmp_path_list) < n_max_collected_paths:\n # # # Append old path to tmp_path list\n tmp_path_list.append(old_path)\n # # # Get next path and its cost\n new_path = next(path_iterator, None)\n # # # Break loop if no path is returned\n if new_path is None:\n break\n new_path_cost = nx.path_weight(self.graph_handler.graph, new_path, weight=\"weight\")\n # # # Check if new cost different to old cost\n if abs(old_path_cost - new_path_cost) > 1e-12:\n same_cost = False\n # # # Overwrite old path with new path\n old_path = new_path\n\n # # # Append path with most nodes to tuple list and its cost\n path_tuple_list.append((max(tmp_path_list, key=lambda x: len(x)), # pylint: disable=unnecessary-lambda\n old_path_cost))\n # # # Break counter loop if no more paths to target are found\n if new_path is None:\n break\n old_path_cost = new_path_cost\n counter += 1\n # # # Store iterator and path info (list of nodes and length)\n if new_path is not None:\n self._unique_iterator_memory = ((new_path, new_path_cost), path_iterator)\n return path_tuple_list","def calc_granger_shuffle(self):\n if not hasattr(self, 'input_data'):\n self.preprocess_and_check_stationarity()\n temp_series = [np.stack([np.random.permutation(x)\n for x in self.input_data.T]).T\n for i in trange(self.n_shuffles)]\n\n outs_temp = parallelize(self.calc_granger, temp_series, n_jobs=30)\n outs_temp = [x[0] for x in outs_temp]\n self.shuffle_outs = np.array(outs_temp)","def generate_pairs(self, all_walks):\n logging.info(['edge_types before generate pairs', self.edge_types])\n\n pairs = []\n skip_window = self.config['win_size'] // 2\n for layer_id, e_type in enumerate(self.edge_types):\n walks = all_walks[e_type]\n for walk in tqdm.tqdm(walks):\n for i in range(len(walk)):\n for j in range(1, skip_window + 1):\n if i - j >= 0 and walk[i] != walk[i - j]:\n neg_nodes = self.graph[e_type].sample_nodes(\n self.config['neg_num'])\n pairs.append(\n (walk[i], walk[i - j], *neg_nodes, layer_id))\n if i + j < len(walk) and walk[i] != walk[i + j]:\n neg_nodes = self.graph[e_type].sample_nodes(\n self.config['neg_num'])\n pairs.append(\n (walk[i], walk[i + j], *neg_nodes, layer_id))\n return pairs","def __generate_connecticity_increasing_canidates(self,k=3):\n result = set()\n \n if k < 3:\n k = 3\n \n self.__logger.info(\"IMPROOVE_NETWORK: Try to seek {} nodes which are currently bad connected\".format(k))\n candidates = heapq.nlargest(3*k, self.__generate_all_shortest_paths(), key=itemgetter(0))\n\n for _, path in candidates:\n result.add(path[0])\n result.add(path[-1])\n\n self.__logger.info(\"IMPROOVE_NETWORK: Found {} candidates which are currently bad connected\".format(len(result))) \n if len(result) <= k:\n return list(result)\n self.__logger.info(\"IMPROOVE_NETWORK: Sample {} items from the candidates as was requested\".format(k))\n tmp = list(result)\n random.shuffle(tmp)\n return tmp[0:k]","def generate_simple_flows(tgen_names, num_bots, bot_msg_size, bot_msg_rate, num_comps, comp_msg_size, comp_msg_rate):\n bot_tgen_ips = [TGEN_IP_PATTERN.format(TGEN_SUBNET_BASE + i) for i in range(num_bots)]\n bot_tgen_ports = [TGEN_PORT_BASE + i for i in range(num_bots)]\n\n # competitor IPs and port numbers start after those assigned to the bots\n comp_tgen_ips = [TGEN_IP_PATTERN.format(TGEN_SUBNET_BASE + i) for i in range(num_bots, num_bots+num_comps)]\n comp_tgen_ports = [TGEN_PORT_BASE + i for i in range(num_bots, num_bots+num_comps)]\n\n # build up flows for bots. Each bot talks to every other bot.\n bot_flows = {}\n for i in range(num_bots):\n bot_flows[i] = {\"flows\": [], \"tgen_name\": tgen_names[i]}\n\n # add a flow for each neighbor bot\n for j in range(len(bot_tgen_ips)):\n # don't add flows to self\n if i != j:\n # send from a unique source port based on the DESTINATION node.\n # use a destination port based on the SOURCE node number\n bot_flows[i][\"flows\"].append({\"src_port\": bot_tgen_ports[j],\n \"dst_ip\": bot_tgen_ips[j],\n \"dst_port\": bot_tgen_ports[i],\n \"msg_rate\": bot_msg_rate,\n \"msg_size\": bot_msg_size,\n })\n\n # build up flows for competitor nodes. Each competitor node talks to every other competitor node.\n comp_flows = {}\n for i in range(num_comps):\n comp_flows[i] = {\"flows\": [], \"tgen_name\": tgen_names[i+num_bots]}\n\n # add a flow for each neighbor bot\n for j in range(len(comp_tgen_ips)):\n # don't add flows to self\n if i != j:\n # send from a unique source port based on the DESTINATION node.\n # use a destination port based on the SOURCE node number\n comp_flows[i][\"flows\"].append({\"src_port\": comp_tgen_ports[j],\n \"dst_ip\": comp_tgen_ips[j],\n \"dst_port\": comp_tgen_ports[i],\n \"msg_rate\": comp_msg_rate,\n \"msg_size\": comp_msg_size,\n })\n\n return bot_flows, comp_flows","def _measure(d, sources, target, niter=25, bound=None):\n uniques = {}\n for source in sources:\n others = list(sources)\n others.remove(source)\n others = list(flatten(others))\n uniques[source] = one_way_skar(d, target, source, others)\n return uniques","def generate_parameters_random_walk():\r\n\r\n logging.info('Loading distances_nets from disk...')\r\n\r\n\r\n\r\n sum_weights = {}\r\n\r\n amount_edges = {}\r\n\r\n\r\n\r\n layer = 0\r\n\r\n while is_pickle('distances_nets_weights-layer-' + str(layer)):\r\n\r\n logging.info('Executing layer {}...'.format(layer))\r\n\r\n weights = restore_variable_from_disk('distances_nets_weights-layer-' + str(layer))\r\n\r\n\r\n\r\n for node, list_weights in weights.items():\r\n\r\n if layer not in sum_weights:\r\n\r\n sum_weights[layer] = 0\r\n\r\n if layer not in amount_edges:\r\n\r\n amount_edges[layer] = 0\r\n\r\n\r\n\r\n for w in list_weights:\r\n\r\n sum_weights[layer] += w\r\n\r\n amount_edges[layer] += 1\r\n\r\n\r\n\r\n logging.info('Layer {} executed.'.format(layer))\r\n\r\n layer += 1\r\n\r\n\r\n\r\n average_weight = {}\r\n\r\n for layer in sum_weights.keys():\r\n\r\n average_weight[layer] = sum_weights[layer] / amount_edges[layer]\r\n\r\n\r\n\r\n logging.info(\"Saving average_weights on disk...\")\r\n\r\n save_variable_on_disk(average_weight, 'average_weight')\r\n\r\n\r\n\r\n amount_neighbours = {}\r\n\r\n\r\n\r\n layer = 0\r\n\r\n while is_pickle('distances_nets_weights-layer-' + str(layer)):\r\n\r\n logging.info('Executing layer {}...'.format(layer))\r\n\r\n weights = restore_variable_from_disk('distances_nets_weights-layer-' + str(layer))\r\n\r\n\r\n\r\n amount_neighbours[layer] = {}\r\n\r\n\r\n\r\n for node, list_weights in weights.items():\r\n\r\n cont_neighbours = 0\r\n\r\n for w in list_weights:\r\n\r\n if w > average_weight[layer]:\r\n\r\n cont_neighbours += 1\r\n\r\n amount_neighbours[layer][node] = cont_neighbours\r\n\r\n\r\n\r\n logging.info('Layer {} executed.'.format(layer))\r\n\r\n layer += 1\r\n\r\n\r\n\r\n logging.info(\"Saving amount_neighbours on disk...\")\r\n\r\n save_variable_on_disk(amount_neighbours, 'amount_neighbours')","def simulate_graph(seed, cluster_sizes, del_factor, ins_factor):\n rand.seed(seed)\n cluster_boundaries = np.cumsum(cluster_sizes)\n print(\"#seed:\", seed)\n print(\"#deletion factor:\", del_factor)\n print(\"#insertion factor:\", ins_factor)\n optimal_costs = np.array([0])\n for c in range(0, len(cluster_sizes)-1):\n n_c = cluster_sizes[c+1]\n offset_c = cluster_boundaries[c]\n edges_c = generate_edges(n_c, offset_c)\n disturb_cluster(n_c, offset_c, edges_c, del_factor, optimal_costs)\n additional_edges(cluster_boundaries, ins_factor, optimal_costs)\n print(\"#optimal costs:\", optimal_costs)","def generate_visiting_scheme(self):\n\n def all_indices_shuffled():\n _res = list(range(self.dataset.num_examples))\n self.rnd.shuffle(_res)\n return _res\n\n # noinspection PyUnusedLocal\n _tmp_ts = np.concatenate(\n [all_indices_shuffled() for _ in range(self.epochs or 1)]\n )\n self.training_schedule = (\n _tmp_ts\n if self.training_schedule is None\n else np.concatenate([self.training_schedule, _tmp_ts])\n ) # do not discard previous schedule,\n # this should allow backward passes of arbitrary length\n\n return self","def choose_paths_without_simulation(FT, output_dir, iteration, pathset_paths_df, pathset_links_df, veh_trips_df):\n simulation_iteration = 0\n ######################################################################################################\n FastTripsLogger.info(\" Step 1. Find out board/alight times for all pathset links from vehicle times\")\n\n # could do this just to chosen path links but let's do this to the whole pathset\n pathset_links_df = Assignment.find_passenger_vehicle_times(pathset_links_df, veh_trips_df)\n\n # instead of flag_missed_transfers(), set these to pathfinding results\n pathset_links_df[Assignment.SIM_COL_PAX_ALIGHT_DELAY_MIN] = 0\n pathset_links_df[Assignment.SIM_COL_PAX_A_TIME ] = pathset_links_df[Passenger.PF_COL_PAX_A_TIME]\n pathset_links_df[Assignment.SIM_COL_PAX_B_TIME ] = pathset_links_df[Passenger.PF_COL_PAX_B_TIME]\n pathset_links_df[Assignment.SIM_COL_PAX_LINK_TIME ] = pathset_links_df[Passenger.PF_COL_LINK_TIME]\n pathset_links_df[Assignment.SIM_COL_PAX_WAIT_TIME ] = pathset_links_df[Passenger.PF_COL_WAIT_TIME]\n pathset_links_df[Assignment.SIM_COL_PAX_MISSED_XFER ] = 0\n\n ######################################################################################################\n FastTripsLogger.info(\" Step 2. Calculate costs and probabilities for all pathset paths\")\n (pathset_paths_df, pathset_links_df) = PathSet.calculate_cost(\n iteration, simulation_iteration, Assignment.STOCH_DISPERSION,\n pathset_paths_df, pathset_links_df, FT.passengers.trip_list_df,\n FT.transfers.transfers_df, FT.tazs.walk_df, FT.tazs.drive_df, veh_trips_df, FT.stops)\n\n ######################################################################################################\n FastTripsLogger.info(\" Step 3. Choose a path for each passenger from their pathset\")\n\n # Choose path for each passenger -- pathset_paths_df and pathset_links_df will now have\n # SIM_COL_PAX_CHOSEN >=0 for chosen paths/path links\n (num_passengers_arrived, num_chosen, pathset_paths_df, pathset_links_df) = Passenger.choose_paths(\n True, # choose for everyone\n iteration, simulation_iteration,\n pathset_paths_df, pathset_links_df)\n\n # Write the pathsets\n Passenger.write_paths(output_dir, iteration, simulation_iteration, pathset_paths_df, False, Assignment.OUTPUT_PATHSET_PER_SIM_ITER)\n Passenger.write_paths(output_dir, iteration, simulation_iteration, pathset_links_df, True, Assignment.OUTPUT_PATHSET_PER_SIM_ITER)\n\n # write the final chosen paths for this iteration\n chosen_links_df = Passenger.get_chosen_links(pathset_links_df)\n chosen_links_df[\"iteration\"] = iteration\n Util.write_dataframe(chosen_links_df, \"chosen_links_df\", os.path.join(output_dir, \"chosenpaths_links.csv\"), append=(iteration>1))\n chosen_links_df.drop([\"iteration\"], axis=1, inplace=True)\n\n chosen_paths_df = Passenger.get_chosen_links(pathset_paths_df)\n chosen_paths_df[\"iteration\"] = iteration\n Util.write_dataframe(chosen_paths_df, \"chosen_paths_df\", os.path.join(output_dir, \"chosenpaths_paths.csv\"), append=(iteration>1))\n chosen_paths_df.drop([\"iteration\"], axis=1, inplace=True)\n\n return (num_passengers_arrived, pathset_paths_df, pathset_links_df)","def generate(\n self,\n num_nodes_src_set: int,\n num_nodes_dst_set: int,\n num_edges_src_dst: int,\n num_edges_dst_src: int,\n is_directed: bool,\n return_node_ids: bool = False,\n transform_graph: bool = True,\n *args,\n **kwargs,\n ):\n raise NotImplementedError()","def k_shortest_paths(G, source, target, k=1, weight='weight'):\n\tif source == target:\n\t\treturn ([0], [[source]]) \n\t \n\tlength, path = nx.single_source_dijkstra(G, source, target, weight=weight)\n\tif target not in length:\n\t\traise nx.NetworkXNoPath(\"node %s not reachable from %s\" % (source, target))\n\t\t\n\tlengths = [length[target]]\n\tpaths = [path[target]]\n\tc = count()\t\t\n\tB = []\t\t\t\t\t\t\n\tG_original = G.copy()\t\n\t\n\tfor i in range(1, k):\n\t\tfor j in range(len(paths[-1]) - 1):\t\t\t\n\t\t\tspur_node = paths[-1][j]\n\t\t\troot_path = paths[-1][:j + 1]\n\t\t\t\n\t\t\tedges_removed = []\n\t\t\tfor c_path in paths:\n\t\t\t\tif len(c_path) > j and root_path == c_path[:j + 1]:\n\t\t\t\t\tu = c_path[j]\n\t\t\t\t\tv = c_path[j + 1]\n\t\t\t\t\tif G.has_edge(u, v):\n\t\t\t\t\t\tedge_attr = G.edge[u][v]\n\t\t\t\t\t\tG.remove_edge(u, v)\n\t\t\t\t\t\tedges_removed.append((u, v, edge_attr))\n\t\t\t\n\t\t\tfor n in range(len(root_path) - 1):\n\t\t\t\tnode = root_path[n]\n\t\t\t\t# out-edges\n\t\t\t\tfor u, v, edge_attr in G.copy().edges_iter(node, data=True):\n\t\t\t\t\tG.remove_edge(u, v)\n\t\t\t\t\tedges_removed.append((u, v, edge_attr))\n\t\t\t\t\n\t\t\t\tif G.is_directed():\n\t\t\t\t\t# in-edges\n\t\t\t\t\tfor u, v, edge_attr in G.in_edges_iter(node, data=True):\n\t\t\t\t\t\tG.remove_edge(u, v)\n\t\t\t\t\t\tedges_removed.append((u, v, edge_attr))\n\t\t\t\n\t\t\tspur_path_length, spur_path = nx.single_source_dijkstra(G, spur_node, target, weight=weight)\t\t\t\n\t\t\tif target in spur_path and spur_path[target]:\n\t\t\t\ttotal_path = root_path[:-1] + spur_path[target]\n\t\t\t\ttotal_path_length = get_path_length(G_original, root_path, weight) + spur_path_length[target]\t\t\t\t\n\t\t\t\theappush(B, (total_path_length, next(c), total_path))\n\t\t\t\t\n\t\t\tfor e in edges_removed:\n\t\t\t\tu, v, edge_attr = e\n\t\t\t\tG.add_edge(u, v, edge_attr)\n\t\t\t\t\t \n\t\tif B:\n\t\t\t(l, _, p) = heappop(B)\n\t\t\tlengths.append(l)\n\t\t\tpaths.append(p)\n\t\telse:\n\t\t\tbreak\n\t\n\treturn (lengths, paths)","def k_shortest_paths(G, source, target, k=1, weight='weight'):\n\tif source == target:\n\t\treturn ([0], [[source]]) \n\t \n\tlength, path = nx.single_source_dijkstra(G, source, target, weight=weight)\n\tif target not in length:\n\t\traise nx.NetworkXNoPath(\"node %s not reachable from %s\" % (source, target))\n\t\t\n\tlengths = [length[target]]\n\tpaths = [path[target]]\n\tc = count()\t\t\n\tB = []\t\t\t\t\t\t\n\tG_original = G.copy()\t\n\t\n\tfor i in range(1, k):\n\t\tfor j in range(len(paths[-1]) - 1):\t\t\t\n\t\t\tspur_node = paths[-1][j]\n\t\t\troot_path = paths[-1][:j + 1]\n\t\t\t\n\t\t\tedges_removed = []\n\t\t\tfor c_path in paths:\n\t\t\t\tif len(c_path) > j and root_path == c_path[:j + 1]:\n\t\t\t\t\tu = c_path[j]\n\t\t\t\t\tv = c_path[j + 1]\n\t\t\t\t\tif G.has_edge(u, v):\n\t\t\t\t\t\tedge_attr = G.edge[u][v]\n\t\t\t\t\t\tG.remove_edge(u, v)\n\t\t\t\t\t\tedges_removed.append((u, v, edge_attr))\n\t\t\t\n\t\t\tfor n in range(len(root_path) - 1):\n\t\t\t\tnode = root_path[n]\n\t\t\t\t# out-edges\n\t\t\t\tfor u, v, edge_attr in G.copy().edges_iter(node, data=True):\n\t\t\t\t\tG.remove_edge(u, v)\n\t\t\t\t\tedges_removed.append((u, v, edge_attr))\n\t\t\t\t\n\t\t\t\tif G.is_directed():\n\t\t\t\t\t# in-edges\n\t\t\t\t\tfor u, v, edge_attr in G.in_edges_iter(node, data=True):\n\t\t\t\t\t\tG.remove_edge(u, v)\n\t\t\t\t\t\tedges_removed.append((u, v, edge_attr))\n\t\t\t\n\t\t\tspur_path_length, spur_path = nx.single_source_dijkstra(G, spur_node, target, weight=weight)\t\t\t\n\t\t\tif target in spur_path and spur_path[target]:\n\t\t\t\ttotal_path = root_path[:-1] + spur_path[target]\n\t\t\t\ttotal_path_length = get_path_length(G_original, root_path, weight) + spur_path_length[target]\t\t\t\t\n\t\t\t\theappush(B, (total_path_length, next(c), total_path))\n\t\t\t\t\n\t\t\tfor e in edges_removed:\n\t\t\t\tu, v, edge_attr = e\n\t\t\t\tG.add_edge(u, v, edge_attr)\n\t\t\t\t\t \n\t\tif B:\n\t\t\t(l, _, p) = heappop(B)\t\t\n\t\t\tlengths.append(l)\n\t\t\tpaths.append(p)\n\t\telse:\n\t\t\tbreak\n\t\n\treturn (lengths, paths)","def _measure(d, sources, target, niter=25, bound=None):\n uniques = {}\n for source in sources:\n others = list(sources)\n others.remove(source)\n others = list(flatten(others))\n uniques[source] = two_way_skar(d, [source, target], others)\n return uniques","def greedy(self):\n # for each node, find the incoming link with the highest score.\n max_scores = {}\n max_sources = {}\n for source, target in self.iteredges():\n score = self.get_score(source, target)\n max_score = max_scores.get(target)\n if max_score is None or score > max_score:\n max_scores[target] = score\n max_sources[target] = source\n # then build a graph out of just these links.\n succs = dict((n, []) for n in self)\n for target, source in max_sources.items():\n succs[source].append(target)\n return Digraph(succs, self.get_score, self.get_label)","def createTrialBatchesWithDynamics((taskRuleSet,nTasks,shuffle,batchNum)):\n if batchNum%100==0:\n print 'Running batch', batchNum\n\n nMiniblocks = nTasks\n nTasks = nTasks # Corresponds to the number of miniblocks\n n_trials_per_block = 3\n shuffle=True\n \n stimuliSet = task.createSensoryInputs()\n\n networkIO_DataFrame = {}\n networkIO_DataFrame['LogicRule'] = []\n networkIO_DataFrame['SensoryRule'] = []\n networkIO_DataFrame['MotorRule'] = []\n networkIO_DataFrame['Color1'] = []\n networkIO_DataFrame['Color2'] = []\n networkIO_DataFrame['Orientation1'] = []\n networkIO_DataFrame['Orientation2'] = []\n networkIO_DataFrame['Pitch1'] = []\n networkIO_DataFrame['Pitch2'] = []\n networkIO_DataFrame['Constant1'] = []\n networkIO_DataFrame['Constant2'] = []\n networkIO_DataFrame['MotorResponse'] = []\n\n # Create 1d array to randomly sample indices from\n stimIndices = np.arange(len(stimuliSet))\n taskIndices = np.arange(len(taskRuleSet))\n \n randomTaskIndices = np.random.choice(taskIndices,nTasks,replace=False)\n taskRuleSet2 = taskRuleSet.iloc[randomTaskIndices].copy(deep=True)\n taskRuleSet2 = taskRuleSet2.reset_index(drop=True)\n taskRuleSet = taskRuleSet2.copy(deep=True)\n\n# networkInputCode = []\n# networkOutputCode = []\n# for taskrule in taskRuleSet.index:\n# \n# randomStimuliIndices = np.random.choice(stimIndices,n_trials_per_block,replace=False)\n# stimuliSet2 = stimuliSet.iloc[randomStimuliIndices].copy(deep=True)\n# stimuliSet2 = stimuliSet2.reset_index(drop=True)\n# \n# for trial in stimuliSet2.index:\n#\n# networkInputCode.append(np.hstack((taskRuleSet.Code[taskrule], stimuliSet2.Code[trial])))\n# tmpresp, tmpcode = task.solveInputs(taskRuleSet.iloc[taskrule], stimuliSet2.iloc[trial])\n# networkOutputCode.append(tmpcode)\n\n \n\n ####\n # Construct trial dynamics\n rule_ind = np.arange(12) # rules are the first 12 indices of input vector\n stim_ind = np.arange(12,28) # stimuli are the last 16 indices of input vector\n input_size = len(rule_ind) + len(stim_ind)\n n_tp_total = 36 # total length of miniblock -- cpro task details\n input_matrix = np.zeros((input_size,n_tp_total,nMiniblocks))\n output_matrix = np.zeros((4,n_tp_total,nMiniblocks))\n trial = 0\n for block in range(nMiniblocks):\n # Define trial dynamics\n n_tp_encoding = 5\n n_tp_encodingdelay = np.random.randint(2,9) # encoding delay is jittered from 2 - 8 trs\n n_tp_trial = 3\n n_tp_probedelay = 2\n n_tp_trial_end = n_tp_total - n_tp_encoding - n_tp_encodingdelay - n_tp_trial*3 - n_tp_probedelay*2 # full miniblock is 36 trs\n\n\n rand_stim_ind = np.random.choice(stimIndices,n_trials_per_block,replace=False)\n stimuliSet2 = stimuliSet.iloc[rand_stim_ind].copy(deep=True)\n stimuliSet2 = stimuliSet2.reset_index(drop=True)\n \n # Create trial array\n networkInputCode2 = []\n networkOutputCode2 = []\n tp = 0\n # Encoding\n for i in range(n_tp_encoding):\n input_matrix[rule_ind,tp,block] = taskRuleSet.Code[block] \n tp += 1\n\n # Encoding delay\n tp += n_tp_encodingdelay\n\n # Trials\n for trial in range(n_trials_per_block):\n # First solve trial\n tmpresp, out_code = task.solveInputs(taskRuleSet.iloc[block], stimuliSet2.iloc[trial])\n\n # probe\n for i in range(n_tp_trial):\n input_matrix[stim_ind,tp,block] = stimuliSet2.Code[trial]\n # Commented out - response period will be limited to ITI following stimulus\n #output_matrix[:,tp,block] = out_code\n tp += 1\n\n # probe delay\n for i in range(n_tp_probedelay):\n output_matrix[:,tp,block] = out_code\n tp += 1\n \n if shuffle:\n ind = np.arange(input_matrix.shape[2],dtype=int)\n np.random.shuffle(ind)\n input_matrix = input_matrix[:,:,ind]\n output_matrix = output_matrix[:,:,ind]\n \n return input_matrix, output_matrix","def get_all_pairs(G):\n # list all (start,dest) pairs between which the route must be computed\n pairs_list = [(start, dest) for dest in G.nodes for start in G.nodes]\n\n # shuffle all elements in-place\n random.shuffle(pairs_list)\n\n # generate a set from the list\n pairs_set = set(pairs_list)\n\n return pairs_list, pairs_set","def shiftFlows(self, targetFlows, stepSize):\n for l in self.link:\n current = self.link[l].flow\n target = targetFlows[l]\n new = current *(1 - stepSize)+target*stepSize\n self.link[l].flow = new\n self.link[l].updateCost()","def step(nodes, outputs, edges):\n flowed = []\n for node_name in nodes.copy():\n if node_name in flowed:\n continue\n if len(nodes[node_name]) == 2:\n if node_name in flowed:\n continue\n node = [int(value) for value in nodes[node_name]]\n low_value, high_value = min(node), max(node)\n low_flow, high_flow = edges[node_name] \n low_dictionary, low_node_name = low_flow\n high_dictionary, high_node_name = high_flow\n low_node = low_dictionary.get(low_node_name, tuple())\n high_node = high_dictionary.get(high_node_name, tuple())\n low_dictionary[low_node_name] = low_node + (str(low_value),)\n high_dictionary[high_node_name] = high_node + (str(high_value),)\n nodes[node_name] = tuple()\n if low_dictionary is nodes:\n flowed.append(low_node_name)\n if high_dictionary is nodes:\n flowed.append(high_node_name)\n return nodes, outputs, edges","def shuffle(self):\n self.edges = np.random.permutation(self.edges)\n self.batch_num = 0","def flowers(self):\n return self._flowers","def sources(self):\n return [x for x in self if self.in_degree(x)==0]","def optimal_route(graph,homes,source):\n number_of_homes = len(homes)\n all_pairs_distances = dict(nx.shortest_path_length(graph, weight = 'weight'))\n all_pairs_shortest_paths = dict(nx.shortest_path(graph, weight = 'weight'))\n homes_subgraph = tsp_routines.complete_shortest_path_subgraph_efficient(graph,homes,all_pairs_distances)\n num_clusters_to_clustering = clustering_routines.all_k_clusters(homes_subgraph,number_of_homes)\n \n cluster_list = range(1,number_of_homes+1)\n optimal_cost = np.Inf\n optimal_dropoffs = dict()\n optimal_route = []\n optimal_num_clusters = 0\n\n\n for num_clusters in cluster_list:\n home_clusters = num_clusters_to_clustering[num_clusters]\n cost, dropoffs, route = solver(graph,homes,source,home_clusters,all_pairs_distances,all_pairs_shortest_paths)\n if cost < optimal_cost:\n optimal_cost = cost\n optimal_route = route \n optimal_dropoffs = dropoffs\n optimal_num_clusters = num_clusters\n\n return optimal_cost, optimal_dropoffs, optimal_route, optimal_num_clusters","def dfs_edges_generator(graph, source, reverse=...):\n ...","def traverse_graph(F, f, s, t, u, sr):\n def get_paths_for_flow(F, s, f):\n \"\"\"\n RETURNS\n A set of outgoing links and corresponding splitting ratios for flow f\n at node s\n \"\"\"\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links\n \n if u == t:\n return [([t], sr)]\n\n outgoing_links = get_paths_for_flow(F, u, f)\n paths_to_t = []\n\n for ((current_node, next_hop), split_ratio) in outgoing_links:\n paths_from_u_to_t = traverse_graph(F, f, s, t, next_hop, split_ratio) \n paths_to_t.extend(paths_from_u_to_t)\n\n paths_to_t_with_u = []\n for path in paths_to_t:\n nodes, sr = path\n new_path = [u] + nodes\n paths_to_t_with_u.append((new_path, sr))\n\n return paths_to_t_with_u","def gen_task_sets_simplegen(nsets):\n start = time()\n eval_task_sets = []\n for util in utils:\n task_sets = []\n for i in range(nsets):\n ts = synth.simplegen(i, util, implicit_deadlines=True)\n synth.synth_c_pmf(ts, distribution_cls=lib.ExpExceedDist)\n synth.set_fixed_priorities(ts)\n task_sets.append(ts)\n eval_task_sets.append(task_sets)\n stop = time()\n print('Task Set Generation SimpleGen: %.3fs' % (stop - start))\n pickle.dump(eval_task_sets, open(task_sets_path + 'task_sets_simplegen', 'wb'))","def _ppsc_gossip(self):\n for i in range(self.s):\n for edges in self.all_edges:\n # for each connected component\n selected_edge = random.choice(edges)\n self._ppsc_gossip_edge(selected_edge)","def _get_allow_all_flows() -> List[FlowDescription]:\n return [\n # Set flow match for all packets\n # Don't set the app_name field\n FlowDescription( # uplink flow\n match=FlowMatch(\n direction=FlowMatch.Direction.Value(\"UPLINK\"),\n ),\n action=FlowDescription.Action.Value(\"PERMIT\"),\n ),\n FlowDescription( # downlink flow\n match=FlowMatch(\n direction=FlowMatch.Direction.Value(\"DOWNLINK\"),\n ),\n action=FlowDescription.Action.Value(\"PERMIT\"),\n ),\n ]","def generate_graph(self):\n temp_graph = [[] for i in xrange(Parameters.num_peers)]\n unconnected = set([i for i in xrange(Parameters.num_peers)])\n while len(unconnected) > 1:\n node1 = random.sample(unconnected, 1)[0]\n unconnected.remove(node1)\n node2 = random.sample(unconnected, 1)[0]\n temp_graph[node2].append(self.nodes[node1])\n temp_graph[node1].append(self.nodes[node2])\n unconnected = set([i for i in xrange(Parameters.num_peers)])\n i = 0\n for i in xrange(Parameters.num_peers*Parameters.num_neighbours/2-Parameters.num_peers):\n a = random.sample(unconnected, 1)[0]\n b = random.sample(unconnected, 1)[0]\n while b == a:\n b = random.sample(unconnected, 1)[0]\n temp_graph[a].append(self.nodes[b])\n temp_graph[b].append(self.nodes[a])\n graph = {}\n for i in xrange(len(self.nodes)):\n graph[\"P_\" + str(i)] = list(set(temp_graph[i]))\n return graph","def _graph_fn_sample_stochastic(distribution):\n return distribution.sample()","def sample_paths(S0, N, u, d, q, M):\n value = S0 * np.ones((M, 1)) # M sample paths at once\n paths = np.zeros((M, N + 1))\n paths[:, 0] = value[:, 0]\n for i in np.arange(1, N + 1, 1): # time steps\n random_values = bernoulli.rvs(size=(M, 1), p=q)\n up_moves = random_values * u\n down_moves = -1 * (random_values - 1) * d\n value = np.multiply(value, up_moves + down_moves)\n paths[:, i] = value[:, 0]\n return paths","def Generate_edges(size, connectedness):\r\n\r\n assert connectedness <= 1\r\n random.seed(10)\r\n for i in range(size):\r\n for j in range(i + 1, size):\r\n if random.randrange(0, 100) <= connectedness * 100:\r\n yield f'{i} {j}'","def run(graph: Graph) -> List[Edge]:\n edges = sorted(WeightedEdge(edge) for edge in graph.get_edges())\n partitions = UnionFind()\n mst = []\n\n for edge in edges:\n added = partitions.union(edge.source, edge.target)\n if added:\n mst.append(edge._edge)\n\n if len(mst) == graph.get_number_of_nodes() - 1:\n break\n\n return mst","def make_heuristic_list():\n heuristics = [lambda n_p: (-n_p[0], (n_p[1] >> 16), (n_p[1] & 0xffff)),\n lambda n_p: (-n_p[0], (n_p[1] & 0xffff), (n_p[1] >> 16)),\n lambda n_p: ((n_p[1] >> 16), -n_p[0], (n_p[1] & 0xffff)),\n lambda n_p: ((n_p[1] & 0xffff), -n_p[0], (n_p[1] >> 16)),\n lambda n_p: ((n_p[1] >> 16), (n_p[1] & 0xffff)),\n lambda n_p: ((n_p[1] & 0xffff), (n_p[1] >> 16))]\n samples = 50\n for ij in range(samples):\n for ratio in range(5):\n split = ij / float(samples - 1)\n heuristics.append(make_angle_heuristic(split, 1.0 - split, ratio))\n return heuristics","def ssf(n, N_max = 6, E_max = 4, time_total = 100 ):\n\n G = nx.DiGraph()\n G.add_edge( 0, 1, time_stamp = 1)\n\n # List of existing nodes, with nodes repeated once for each adjacent edge\n repeated_nodes = [0, 1]\n\n # compute discrete bins for nodes \n DistNodes = _get_distribution( N_max, 0 )\n # compute discrete bins for edges\n DistLinks = _get_distribution( E_max, 1 )\n \n # Start adding the other n - 2 nodes.\n N_current = time_current = 2\n while N_current < n and time_current < time_total + 1:\n # preferential attachment\n N_current = _preferential_attachment( DistNodes, DistLinks, N_current,\n time_total, time_current, n, repeated_nodes, G )\n time_current += 1\n \n# print(time_current, N_current)\n return G","def naiveGlobalRouting(self):\n for e_list in self.s2e.values():\n for e in e_list:\n slot_path = []\n src_slot = self.v2s[e.src]\n dst_slot = self.v2s[e.dst]\n slot_path.append(src_slot)\n\n curr = src_slot\n len_x = src_slot.getLenX()\n len_y = src_slot.getLenY()\n\n # first go in X direction\n x_diff = curr.getPositionX() - dst_slot.getPositionX()\n if x_diff:\n dir = 'LEFT' if x_diff > 0 else 'RIGHT'\n for i in range(int(abs(x_diff/len_x))):\n curr = self.slot_manager.createSlotForRouting(curr.getNeighborSlotName(dir))\n slot_path.append(curr)\n\n y_diff = curr.getPositionY() - dst_slot.getPositionY()\n if y_diff:\n dir = 'DOWN' if y_diff > 0 else 'UP'\n for i in range(int(abs(y_diff/len_y))):\n curr = self.slot_manager.createSlotForRouting(curr.getNeighborSlotName(dir))\n slot_path.append(curr)\n \n assert curr == dst_slot\n \n slot_path = slot_path[1:-1] # exclude the src and the dst\n logging.info(f'{e.name}: {self.v2s[e.src].getName()} -> {self.v2s[e.dst].getName()} : ' + ' '.join(s.getName() for s in slot_path))\n self.e_name2path[e.name] = slot_path","def sample_paths(S0, N, u, d, q, M):\n value = S0*np.ones((M,1)) # M sample paths at once\n paths = np.zeros((M, N+1))\n paths[:,0] = value[:,0]\n for i in np.arange(1, N+1,1): # time steps\n random_values = bernoulli.rvs(size=(M,1),p=q)\n up_moves = random_values*u\n down_moves = -1*(random_values-1)*d \n value = np.multiply(value,up_moves+down_moves)\n paths[:,i] = value[:,0]\n return paths","def random_coaching_graph(num_classes, min_size, max_size, existing_rate):\n\n n = 0\n coaching_graph = graph.Graph(directed=True)\n for i in range(num_classes):\n n += 1\n class_size = random.randint(min_size, max_size)\n coach = infect.User(str(n))\n existing_users = coaching_graph.nodes()\n num_existing = len(existing_users)\n coaching_graph.add_node(coach)\n for j in range(class_size):\n if random.uniform(0,1) > existing_rate or num_existing < 100:\n n += 1\n user = infect.User(str(n))\n else:\n user = random.choice(existing_users)\n\n coaching_graph.add_edge(coach, user)\n\n\n return coaching_graph","def find_all_cycles(s,graph):\n\n grph = u.edge_to_list_dict(graph)\n node_cnt = len(grph)\n k = z.Int(\"k\")\n syms = [z.Int('node%s'%i) for i in range(node_cnt)]\n\n # s.add(syms[0] == 0) # start node is a 0\n s.add(k < node_cnt)\n s.add(k > 1)\n\n o = z.Optimize()\n\n # for source, sinks in sgraph.s_adj_list():\n for i in range(node_cnt):\n s.add(syms[i] >= 0)\n s.add(syms[i] <= k)\n s.add(z.Or([syms[j] == ((syms[i] + 1) % k) for j in grph[i]]) == (syms[i] == 0))\n\n\n r = []\n m = []\n\n # o.minimize(z.Sum([syms[i] for i in range(node_cnt)]))\n s.add(z.Product([syms[i] for i in range(node_cnt)]) == 0)\n done = False\n while not done:\n if s.check() == z.sat:\n m = s.model()\n r.append(m)\n s.add(k != m[k])\n else:\n done = True\n\n return r","def fit(\n self,\n graph: List[Tuple[int, int]],\n src_set: Set[int],\n dst_set: Set[int],\n is_directed: bool,\n transform_graph: bool,\n *args,\n **kwargs,\n ):\n raise NotImplementedError()","def search_shortest_paths(\n self,\n src_nodes: list[TN],\n dst_node: TN,\n operation_src: str,\n operation_dest: str,\n domain: str,\n limit_dest_schemes: list[str],\n *,\n session: \"Session\",\n ) -> dict[TN, list[dict[str, Any]]]:\n\n for rse in itertools.chain(src_nodes, [dst_node], self._multihop_nodes):\n rse.ensure_loaded(load_attributes=True, load_info=True, session=session)\n self.ensure_edges_loaded(session=session)\n\n if self._multihop_nodes:\n # Filter out island source RSEs\n nodes_to_find = {node for node in src_nodes if node.out_edges}\n else:\n nodes_to_find = set(src_nodes)\n\n class _NodeStateProvider:\n _hop_penalty = self._hop_penalty\n\n def __init__(self, node: TN):\n self.enabled: bool = True\n self.cost: _Number = 0\n if node != dst_node:\n try:\n self.cost = int(node.attributes.get('hop_penalty', self._hop_penalty))\n except ValueError:\n self.cost = self._hop_penalty\n\n scheme_missmatch_found = {}\n\n class _EdgeStateProvider:\n def __init__(self, edge: TE):\n self.edge = edge\n self.chosen_scheme = {}\n\n @property\n def cost(self) -> _Number:\n return self.edge.cost\n\n @property\n def enabled(self) -> bool:\n try:\n matching_scheme = rsemgr.find_matching_scheme(\n rse_settings_src=self.edge.src_node.info,\n rse_settings_dest=self.edge.dst_node.info,\n operation_src=operation_src,\n operation_dest=operation_dest,\n domain=domain,\n scheme=limit_dest_schemes if self.edge.dst_node == dst_node and limit_dest_schemes else None,\n )\n self.chosen_scheme = {\n 'source_scheme': matching_scheme[1],\n 'dest_scheme': matching_scheme[0],\n 'source_scheme_priority': matching_scheme[3],\n 'dest_scheme_priority': matching_scheme[2],\n }\n return True\n except RSEProtocolNotSupported:\n scheme_missmatch_found[self.edge.src_node] = True\n return False\n\n paths = {dst_node: []}\n for node, distance, _, edge_to_next_hop, edge_state in self.dijkstra_spf(dst_node=dst_node,\n nodes_to_find=nodes_to_find,\n node_state_provider=_NodeStateProvider,\n edge_state_provider=_EdgeStateProvider):\n nh_node = edge_to_next_hop.dst_node\n edge_state = cast(_EdgeStateProvider, edge_state)\n hop = {\n 'source_rse': node,\n 'dest_rse': nh_node,\n 'hop_distance': edge_state.cost,\n 'cumulated_distance': distance,\n **edge_state.chosen_scheme,\n }\n paths[node] = [hop] + paths[nh_node]\n\n nodes_to_find.discard(node)\n if not nodes_to_find:\n # We found the shortest paths to all desired nodes\n break\n\n result = {}\n for node in src_nodes:\n path = paths.get(node)\n if path is not None:\n result[node] = path\n elif scheme_missmatch_found.get(node):\n result[node] = []\n return result","def k_shortest_paths(\n self,\n G,\n source,\n target,\n k=1,\n weight='weight',\n ):\n\n if source == target:\n return ([0], [[source]])\n\n (length, path) = nx.single_source_dijkstra(G, source, target,\n weight=weight)\n if target not in length:\n raise nx.NetworkXNoPath('node %s not reachable from %s' % (source,\n target))\n\n lengths = [length[target]]\n paths = [path[target]]\n c = count()\n B = []\n\n # Is deep copy really required?\n # Fails due to embedded Ctype objects which can not be pickled\n # # G_original = G.copy()\n # Swapping with shallow copy...will it work?\n\n G_original = G\n if nx.is_directed(G_original):\n G = nx.DiGraph(G_original)\n else:\n G = nx.Graph(G_original)\n\n ######################################\n #TODO: wrap this up somehow\n print ''\n print term.move_up + term.move_up\n ######################################\n print 'getting K:{} paths...'.format(k),\n for i in range(1, k):\n with term.location():\n print i\n for j in range(len(paths[-1]) - 1):\n spur_node = paths[-1][j]\n root_path = (paths[-1])[:j + 1]\n\n edges_removed = []\n for c_path in paths:\n if len(c_path) > j and root_path == c_path[:j + 1]:\n u = c_path[j]\n v = c_path[j + 1]\n if G.has_edge(u, v):\n edge_attr = G.edge[u][v]\n G.remove_edge(u, v)\n edges_removed.append((u, v, edge_attr))\n\n for n in range(len(root_path) - 1):\n node = root_path[n]\n\n # out-edges\n\n for (u, v, edge_attr) in G.edges_iter(node, data=True):\n\n # print 'lala1: {} -> {}'.format(u,v)\n\n G.remove_edge(u, v)\n edges_removed.append((u, v, edge_attr))\n\n if G.is_directed():\n\n # in-edges\n\n for (u, v, edge_attr) in G.in_edges_iter(node,\n data=True):\n\n # print 'lala2: {} -> {}'.format(u,v)\n\n G.remove_edge(u, v)\n edges_removed.append((u, v, edge_attr))\n\n (spur_path_length, spur_path) = nx.single_source_dijkstra(G,\n spur_node, target, weight=weight)\n if target in spur_path and spur_path[target]:\n total_path = root_path[:-1] + spur_path[target]\n total_path_length = self.get_path_length(G_original,\n root_path, weight) + spur_path_length[target]\n heappush(B, (total_path_length, next(c), total_path))\n\n for e in edges_removed:\n (u, v, edge_attr) = e\n G.add_edge(u, v, edge_attr)\n\n if B:\n (l, _, p) = heappop(B)\n lengths.append(l)\n paths.append(p)\n else:\n break\n\n return (lengths, paths)","def er_random_graph_generator(n, p, ng, seed, w_base, w_top):\n\n f_er_graph_list = []\n for i in range(0, ng):\n f_g = nx.erdos_renyi_graph(n, p, seed + i, directed=False)\n for (u, v, w) in f_g.edges(data=True):\n w['weight'] = random.randint(w_base, w_top)\n f_er_graph_list.append(f_g)\n return f_er_graph_list","def generator(self, random, args):\r\n locations = [i for i in range(len(self.weights))]\r\n random.shuffle(locations)\r\n return locations","def shuffle(self):\n sampling_index = np.random.randint(0, self.total_negative_samples, self.neg_paths_per_epoch)\n self.neg_paths_sampled = np.reshape(self.neg_paths[:, sampling_index , :], (-1, self.max_length))\n self.neg_paths_words_sampled = np.reshape(self.neg_paths_words[:, sampling_index, :], (-1, self.max_length))\n if self.schema != 'default':\n self.neg_paths_rel1_sampled = np.reshape(self.neg_paths_rel1[:, sampling_index, :],(-1, self.max_length))\n self.neg_paths_rel2_sampled = np.reshape(self.neg_paths_rel2[:, sampling_index, :],(-1, self.max_length))\n self.neg_paths_rel3_sampled = np.reshape(self.neg_paths_rel3[:, sampling_index, :],(-1, self.max_length))\n self.neg_paths_rel4_sampled = np.reshape(self.neg_paths_rel4[:, sampling_index, :],(-1, self.max_length))\n\n self.questions_shuffled, self.questions_dep_shuffled, self.questions_dep_mask_shuffled,\\\n self.pos_paths_shuffled, \\\n self.pos_paths_rel1_shuffled,self.pos_paths_rel2_shuffled, self.pos_paths_rel3_shuffled, self.pos_paths_rel4_shuffled, \\\n self.neg_paths_shuffled, \\\n self.neg_paths_rel1_shuffled, self.neg_paths_rel2_shuffled,self.neg_paths_rel3_shuffled,self.neg_paths_rel4_shuffled,\\\n self.pos_paths_words_shuffled, self.neg_paths_words_shuffled = \\\n shuffle(self.questions, self.questions_dep, self.questions_dep_mask,\n self.pos_paths,\n self.pos_paths_rel1, self.pos_paths_rel2,self.pos_paths_rel3,self.pos_paths_rel4,\n self.neg_paths_sampled,\n self.neg_paths_rel1_sampled, self.neg_paths_rel2_sampled, self.neg_paths_rel3_sampled, self.neg_paths_rel4_sampled,\n self.pos_paths_words, self.neg_paths_words_sampled)\n else:\n self.questions_shuffled, self.questions_dep_shuffled, self.questions_dep_mask_shuffled,\\\n self.pos_paths_shuffled, self.neg_paths_shuffled,self.pos_paths_words_shuffled, self.neg_paths_words_shuffled = \\\n shuffle(self.questions, self.questions_dep, self.questions_dep_mask,\n self.pos_paths, self.neg_paths_sampled,self.pos_paths_words,self.neg_paths_words_sampled)","def _get_paths(G, nodes, edges, target, weight, available_dist, cache={}):\n\n G_succ = G.succ if G.is_directed() else G.adj\n\n output = []\n visited = set(nodes)\n path_info = []\n source = nodes[-1]\n get_weight = _create_weight_func(G, weight)\n\n for neighbor, neighbor_edge in G_succ[source].items():\n\n if neighbor in visited:\n continue\n\n new_available_dist = available_dist - get_weight(source, neighbor)\n\n if new_available_dist < 0:\n continue\n\n # shortest path key for cache\n sp_key = (source, neighbor, target)\n\n if sp_key not in cache:\n sp = dijkstra(G, neighbor, target, 'length', set([source]), \n new_available_dist)\n\n cache[sp_key] = INF if not sp else sp[1]\n\n if new_available_dist < cache[sp_key]:\n continue\n\n path_info.append((neighbor, neighbor_edge, new_available_dist))\n\n\n for (neighbor, neighbor_edge, new_available_dist) in path_info:\n new_path = nodes + [neighbor]\n new_edges = edges + [neighbor_edge]\n\n if neighbor == target:\n output.append((new_path, new_edges))\n else:\n output.extend(_get_paths(G, new_path, new_edges, target, \n weight, new_available_dist, cache))\n\n return output","def get_all_sghop_info (nffg, return_paths=False):\n sg_map = {}\n for i in nffg.infras:\n for p in i.ports:\n for fr in p.flowrules:\n # if fr.external:\n # continue\n if fr.id not in sg_map:\n # The path is unordered!!\n path_of_shop = []\n flowclass = NFFGToolBox._extract_flowclass(fr.match.split(\";\"))\n sg_map[fr.id] = [None, None, flowclass, fr.bandwidth, fr.delay]\n # We have to find the BEGINNING of this flowrule sequence.\n inbound_link = NFFGToolBox._find_infra_link(nffg, p, outbound=False,\n accept_dyn=True)\n while inbound_link.type != 'DYNAMIC':\n path_of_shop.append(inbound_link)\n if inbound_link.src.node.type == 'SAP':\n break\n # The link is STATIC, and its src is not SAP so it is an Infra.\n prev_fr, prev_p = \\\n NFFGToolBox._get_flowrule_and_its_starting_port(\n inbound_link.src.node, fr.id)\n NFFGToolBox._check_flow_consistencity(sg_map, prev_fr)\n inbound_link = NFFGToolBox._find_infra_link(nffg, prev_p,\n outbound=False,\n accept_dyn=True)\n # 'inbound_link' is DYNAMIC here or it is STATIC and starts from\n # a SAP,\n # so the sequence starts here\n sg_map[fr.id][0] = inbound_link.src\n\n # We have to find the ENDING of this flowrule sequence.\n output_port = NFFGToolBox._get_output_port_of_flowrule(i, fr)\n if output_port is None:\n continue\n outbound_link = NFFGToolBox._find_infra_link(nffg, output_port,\n outbound=True,\n accept_dyn=True)\n while outbound_link.type != 'DYNAMIC':\n path_of_shop.append(outbound_link)\n if outbound_link.dst.node.type == 'SAP':\n break\n # The link is STATIC and its dst is not a SAP so it is an Infra.\n next_fr, _ = NFFGToolBox._get_flowrule_and_its_starting_port(\n outbound_link.dst.node, fr.id)\n # '_' is 'outbound_link.dst'\n next_output_port = NFFGToolBox._get_output_port_of_flowrule(\n outbound_link.dst.node, next_fr)\n NFFGToolBox._check_flow_consistencity(sg_map, next_fr)\n outbound_link = NFFGToolBox._find_infra_link(nffg,\n next_output_port,\n outbound=True,\n accept_dyn=True)\n # the 'outbound_link' is DYNAMIC here or finishes in a SAP, so the\n # flowrule sequence finished here.\n sg_map[fr.id][1] = outbound_link.dst\n\n if return_paths:\n sg_map[fr.id].append(path_of_shop)\n\n return sg_map","def sinks(self):\n s = [node for node in self.nodes() if node.isSink()]\n s.sort(lambda x,y: cmp(x._id, y._id))\n return s","def prepare_k_fold(self, k_fold: int, shuffle: bool = True) \\\n -> List[Tuple[ZLIMGS, ZLIMGS, ZLIMGS, ZLIMGS, ZLIMGS, ZLIMGS]]:\n if self.setting == 'setting1':\n warnings.warn(\"Setting 1 should not use train eval dataset! \"\n \"Because its training set only contain normal samples!\")\n\n with open(self.json_path) as fp:\n ids_json = json.load(fp)\n ids_train_normal = ids_json['normal']['train']\n ids_train_defect = ids_json['defect']['train']\n\n if shuffle:\n self.rnd.shuffle(ids_train_normal)\n self.rnd.shuffle(ids_train_defect)\n ids_folds_normal = chunks(ids_train_normal, k_fold)\n ids_folds_defect = chunks(ids_train_defect, k_fold)\n\n zlimgs_folds = []\n for k in range(k_fold):\n _ids_folds_normal = ids_folds_normal.copy()\n _ids_folds_defect = ids_folds_defect.copy()\n ids_k_dev_normal = _ids_folds_normal.pop(k)\n ids_k_dev_defect = _ids_folds_defect.pop(k)\n ids_k_train_normal = list(itertools.chain(*_ids_folds_normal))\n ids_k_train_defect = list(itertools.chain(*_ids_folds_defect))\n\n # train\n zlimgs_k_train_normal = self._create_zl_imgs_given_ids(ids=ids_k_train_normal,\n subset=CONFIG[self.setting]['normal_train'],\n ann_type=CONFIG[self.setting]['ann_train'])\n zlimgs_k_train_defect = self._create_zl_imgs_given_ids(ids=ids_k_train_defect,\n subset=CONFIG[self.setting]['defect_train'],\n ann_type=CONFIG[self.setting]['ann_train'])\n # train-eval\n zlimgs_k_train_eval_normal = self._create_zl_imgs_given_ids(ids=ids_k_train_normal,\n subset=CONFIG[self.setting]['normal_train'],\n ann_type=CONFIG[self.setting]['ann_eval'])\n zlimgs_k_train_eval_defect = self._create_zl_imgs_given_ids(ids=ids_k_train_defect,\n subset=CONFIG[self.setting]['defect_train'],\n ann_type=CONFIG[self.setting]['ann_eval'])\n # dev\n zlimgs_k_dev_normal = self._create_zl_imgs_given_ids(ids=ids_k_dev_normal, subset='dev',\n ann_type=CONFIG[self.setting]['ann_eval'])\n zlimgs_k_dev_defect = self._create_zl_imgs_given_ids(ids=ids_k_dev_defect, subset='dev',\n ann_type=CONFIG[self.setting]['ann_eval'])\n zlimgs_folds.append((zlimgs_k_train_normal, zlimgs_k_train_defect,\n zlimgs_k_train_eval_normal, zlimgs_k_train_eval_defect,\n zlimgs_k_dev_normal, zlimgs_k_dev_defect))\n return zlimgs_folds","def get_diffuse_sources(self, src_sel):\n extended = self._select_and_freeze(self.extended_sources, src_sel)\n for s in extended: # this seems redundant, but was necessary\n s.model.free[:] = False if src_sel.frozen(s) else s.free[:]\n sources.validate(s,self.nside, None)\n s.smodel = s.model\n \n return self.get_global_sources(src_sel.skydir()), extended","def prepare_data_for_g(self):\n\n paths = []\n for i in self.root_nodes:\n if np.random.rand() < config.update_ratio:\n sample, paths_from_i = self.sample(i, self.trees[i], config.n_sample_gen, for_d=False)\n if paths_from_i is not None:\n paths.extend(paths_from_i)\n # for each root, we generate 20 samples, each sample is equal to one path from root to that sample\n # So, we will get maximum (num_root x 20) paths\n # path is a list with length = (N x num_sample), with num_sample = 20\n # paths =[[path_root1_to_sample1],[path_root1_to_sample2],....,[path_root1_to_sample20],\n # [path_root2_to_sample1],[path_root2_to_sample2],....,[path_root2_to sample20]\n # .\n # .\n # [path_rootN_to_sample1],[path_rootN_to_sample2],....,[path_rootN_to_sample20]]\n # get_node_pairs_from_path\n\n node_pairs = list(map(self.get_node_pairs_from_path, paths))\n # node_pairs = [[node pairs for path_root1_to_sample1],[node pairs for path_root1_to_sample2],....,[node pairs for path_root1_to_sample20],\n # [node_pairs for path_root2_to_sample1],[node pairs for path_root2_to_sample2],....,[node pairs for path_root2_to sample20],\n # .\n # .\n # [node pairs for path_rootN_to_sample1],[node pairs for path_rootN_to_sample2],....,[node pairs for path_rootN_to_sample20]]\n\n node_1 = []\n node_2 = []\n for i in range(len(node_pairs)):\n for pair in node_pairs[i]:\n node_1.append(pair[0])\n node_2.append(pair[1])\n # reward = self.sess.run(self.discriminator.reward,\n # feed_dict={self.discriminator.node_id: np.array(node_1),\n # self.discriminator.node_neighbor_id: np.array(node_2)})\n reward = self.discriminator.forward(node_1, node_2)\n return node_1, node_2, reward","def bounded_bfs_paths(G,sources,max_depth=None):\n\t# Based on http://www.ics.uci.edu/~eppstein/PADS/BFS.py\n\t# by D. Eppstein, July 2004.\n\tvisited=set(sources)\n\tdepth=0\n\tstack = []\n\tfor source in sources:\n\t\tstack.append((source,iter(G[source]),depth,[source]))\n\twhile stack:\n\t\t# print stack\n\t\tparent,children,last_depth,path = stack[0]\n\t\tdepth=last_depth+1\n\t\tif (max_depth) and (depth > max_depth):\n\t\t\tbreak\n\t\ttry:\n\t\t\tchild = next(children)\n\t\t\t# if child not in visited:\n#\t\t\tyield parent,child\n#\t\t\tvisited.add(child)\n\t\t\tif child not in path :\n\t\t\t\tyield path+[child]\n\t\t\t\tstack.append((child,iter(G[child]),depth,path+[child]))\n\t\texcept StopIteration:\n\t\t\tstack.pop(0)","def reset(self):\n\t\tself.globalQueue = PriorityQueue()\n\t\tself.simTime = 0\n\t\tself.sources = []\n\t\tfor i in range(self.no_of_sources):\n\t\t\t# s = Source(random.random())#, transfer_rate = 4, packet_size = 100, bandwidth = 1000, switch = None)\n\t\t\ts = Source(random.random(), transfer_rate = self.source_tranfer_rate[i], packet_size = 100, bandwidth = self.source_bandwith[i], switch = None)\n\t\t\tself.sources.append(s)\n\t\tself.switch = Switch(output_bandwidth =self.output_bandwidth, source_list = self.sources, queue_size = self.queue_size, sink = None)\n\t\tself.switch.list_sources()\n\t\tself.sink = Sink(switch =self.switch)\n\t\t# connect the sink to the switch\n\t\tself.switch.add_sink(self.sink)\n\t\t# now we need to add the switch to the source\n\t\tfor s in self.sources:\n\t\t\ts.connect_to_switch(self.switch)\n\t\t## all connections have been done\n\t\t# no packets and push into queue_size\n\t\tinitial_events = []\n\t\tfor s in self.sources:\n\t\t\te = s.Produce_Event0(self.simTime)\n\t\t\tinitial_events.append(e)\n\t\t\tself.globalQueue.put(e)","def generateNumsets(G):\n # paths = []\n #\n # path = [0]\n # for edge in nx.dfs_edges(G, 0):\n # if edge[0] == path[-1]:\n # path.append(edge[1])\n # else:\n # paths.append(path)\n # search_index = 2\n # while search_index <= len(path):\n # if edge[0] == path[-search_index]:\n # path = path[:-search_index + 1] + [edge[1]]\n # break\n # search_index += 1\n # else:\n # raise Exception(\"Wrong path structure?\", path, edge)\n # paths.append(path)\n # return paths\n\n \"\"\"\n Trying to use itertools LMAO\n \"\"\"\n # paths = []\n #\n # for path in itertools.combinations(G.nodes, 5):\n # paths.append(path)\n # return paths\n\n \"\"\"\n Generating paths using graph\n \"\"\"\n paths = []\n n = len(G.nodes)\n for source in range(n):\n for target in range(source+1, n):\n paths.extend([path for path in nx.all_simple_paths(G, source=source, target=target)])\n return paths\n\n # return paths"],"string":"[\n \"def compute_path_hopping_flow_allocations(target_graph, K=3):\\n flow_allocation_seed_number = 0xCAFE_BABE\\n np.random.seed(flow_allocation_seed_number)\\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\\n link_utilization = {(u, v): 0.0 for u, v in target_graph.edges}\\n node_capacity = {u: 0.0 for u in target_graph.nodes}\\n flows = []\\n while True:\\n source_node, destination_node = flow_selection_fn(target_graph.nodes, 2, replace=False)\\n print(source_node, destination_node)\\n\\n shortest_paths = sorted(nx.all_simple_paths(target_graph, source_node, destination_node,\\n cutoff=3),\\n key=lambda p: len(p))\\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\\n\\n # flow_tx_rate = np.random.uniform() * 10\\n flow_tx_rate = 1.0\\n # if node_capacity[source_node] + flow_tx_rate > LINK_CAPACITY:\\n # break\\n node_capacity[source_node] += flow_tx_rate\\n capacity_was_exceeded = False \\n for path in [nx.utils.pairwise(p_i) for p_i in k_shortest_paths]:\\n for u, v in [sorted(h_i) for h_i in path]:\\n flow_rate_per_subpath = flow_tx_rate / K\\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\\n capacity_was_exceeded = True\\n break\\n link_utilization[u, v] += flow_rate_per_subpath\\n if capacity_was_exceeded:\\n break\\n\\n if capacity_was_exceeded:\\n break\\n\\n the_flow = Flow( source_node = source_node\\n , destination_node = destination_node\\n , flow_tx_rate = flow_tx_rate\\n , paths = k_shortest_paths\\n , splitting_ratio = [1.0/K]*K\\n )\\n flows.append(the_flow)\\n return flows, link_utilization\",\n \"def compute_equal_flow_allocations(target_graph, K=3):\\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\\n flow_allocation_seed_number = 0xDEAD_BEEF\\n np.random.seed(flow_allocation_seed_number)\\n flows = []\\n for node in target_graph.nodes:\\n possible_destination_nodes = set(target_graph.nodes) - set([node])\\n [destination_node] = np.random.choice(list(possible_destination_nodes), 1, replace=False)\\n # shortest_paths = all_shortest_paths(target_graph, node, destination_node.item())\\n shortest_paths = sorted(nx.all_simple_paths(target_graph, node, destination_node.item(),\\n cutoff=3),\\n key=lambda p: len(p))\\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\\n the_flow = Flow( source_node = node\\n , destination_node = destination_node.item()\\n , flow_tx_rate = 10.0\\n , paths = k_shortest_paths\\n , splitting_ratio = [1/K]*K\\n )\\n flows.append(the_flow)\\n \\n return flow_allocation_seed_number, flows\",\n \"def bfsSample(G, source=None, k = 50):\\n\\twarn(\\\"networkit.sampling.bfsSample is deprecated, will be removed in future updates.\\\")\\n\\tif not source:\\n\\t\\tsource = GraphTools.randomNode(G)\\n\\tn = G.numberOfNodes()\\n\\tvisited = [False]*n\\n\\tQ = [source]\\n\\tclosest = set([source])\\n\\tglobal found\\n\\tfound = 0\\n\\twhile len(Q) > 0 and found < k:\\n\\t\\tu = Q.pop(0)\\n\\t\\tdef enqueue(u,v,weight, eid):\\n\\t\\t\\tglobal found\\n\\t\\t\\tif not visited[v] and found < k:\\n\\t\\t\\t\\tfound += 1\\n\\t\\t\\t\\tvisited[v] = True\\n\\t\\t\\t\\tQ.append(v)\\n\\t\\t\\t\\tclosest.add(v)\\n\\t\\tG.forEdgesOf(u, enqueue)\\n\\tprint(\\\"found {0} nodes\\\".format(len(closest)))\\n\\tG1 = GraphTools.subgraphFromNodes(G, closest)\\n\\treturn G1\",\n \"def compute_unequal_flow_allocations(target_graph, K=3):\\n\\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\\n flow_allocation_seed_number = 0xDEAD_BEEF\\n np.random.seed(flow_allocation_seed_number)\\n flows = []\\n link_utilization = {}\\n for node in target_graph.nodes:\\n possible_destination_nodes = set(target_graph.nodes) - {node}\\n destination_node = np.random.choice(list(possible_destination_nodes), 1, \\n replace=False).item()\\n shortest_path = nx.shortest_path(target_graph, node, destination_node)\\n the_flow = Flow( source_node = node\\n , destination_node = destination_node\\n , flow_tx_rate = 10.0\\n , paths = [shortest_path]\\n , splitting_ratio = [1.0]\\n )\\n flows.append(the_flow)\\n\\n return flow_allocation_seed_number, flows\",\n \"def generate_graph(size, number_of_clusters, minimal_size):\\n base_list = list(range(size))\\n result_list = []\\n random.shuffle(base_list)\\n for i in range(number_of_clusters - 1):\\n size = random.randint(minimal_size, len(base_list) - (number_of_clusters - i - 1) * minimal_size)\\n cluster = []\\n for n in range(size):\\n actual = random.choice(base_list)\\n base_list.remove(actual)\\n cluster.append(actual)\\n result_list.append(strongly_connect(cluster))\\n result_list.append(strongly_connect(base_list))\\n\\n while len(result_list) < 5:\\n result_list.append([])\\n\\n print(sorted([len(i) for i in result_list], reverse=True)[:5])\\n\\n return weak_connect_graph(result_list)\",\n \"def get_pathologic_covering_routes(n_pl, n_target, attacker_strategy, target_values):\\n # computes the coefficient used by the greedy oracle to choose routes\\n targets_coeff = np.transpose(np.multiply(attacker_strategy, target_values))\\n\\n # randomly selects the player for which the non optimal choice will be made\\n wrong_pl = randint(1, n_pl)\\n\\n # generate the non optimal route randomly\\n n_covered_targets = randint(n_pl,n_target-1)\\n non_opt_action = np.zeros(n_target)\\n for i in range(0, n_covered_targets):\\n random_covered_target = randint(0, n_target-1)\\n non_opt_action[random_covered_target] = 1\\n\\n # compute the value of the non optimal route\\n non_opt_val = get_value_single_route(non_opt_action, targets_coeff)\\n\\n # generate routes that have, as a single, values smaller than the best greedy route but taken togher perform\\n # at least as well. [[0,1,...],[...],...] a[r][t]=1 iff t is covered by r.\\n # The returned list should have n_pl - 1 routes\\n opt_routes = get_opt_routes(n_pl, non_opt_action)\\n\\n I={}\\n for pl in range(1, n_pl+1):\\n\\n n_r = randint(0, MAX_ROUTES)\\n temp = lil_matrix((n_r+1, n_target), dtype='int8')\\n\\n if pl == wrong_pl:\\n # put the non opt route in the bucket\\n for t in non_opt_action.nonzero():\\n temp[0,t] = 1\\n else:\\n for t in opt_routes.pop().nonzero():\\n temp[0,t] = 1\\n\\n # generate other random routes with single value less than the non_opt_value\\n for r in range(1, n_r):\\n new_route = get_r_limited_val(non_opt_val, targets_coeff)\\n\\n for t in new_route.nonzero():\\n temp[r,t] = 1\\n\\n I[pl] = temp.tocsr()\\n\\n return I\",\n \"def multipleTravellingSalesmen(self, iterations=None):\\n if not iterations:\\n iterations = self.mTSPIterations\\n\\n # Randomly select points drawn from unvisited and distribute equally among the ships\\n paths = self.partition(self.unvisited.keys(), len(self.ships))\\n [path.append(ship) for path, ship in zip(paths, self.ships)]\\n\\n # Run single travelling salesman on each of the ships\\n paths = [self.singleTravellingSalesman(path, iterations=0) for path in paths]\\n\\n\\n # IF TWO OR MORE SHIPS!!!\\n # Point exchange between ships and rerun tsp on each ship\\n if len(self.ships) > 1:\\n for _ in range(iterations):\\n twopathindices = random.sample(xrange(len(paths)), 2)\\n newtwopaths = self.swapTwoPointsBetweenPaths([paths[index] for index in twopathindices])\\n newtwopaths = [self.singleTravellingSalesman(path, iterations=max(len(path), 100)) for path in\\n newtwopaths]\\n if self.totalPathDistance(newtwopaths) < self.totalPathDistance(\\n [paths[index] for index in twopathindices]):\\n for i, index in enumerate(twopathindices):\\n paths[index] = newtwopaths[i]\\n\\n return paths\",\n \"def get_paths_for_flow(F, s, f):\\n links = [((u, v), split_ratio) \\n for (flow_id, u, v), split_ratio in F.items() \\n if flow_id == f and u == s and split_ratio > 0.001]\\n return links\",\n \"def get_paths_for_flow(F, s, f):\\n links = [((u, v), split_ratio) \\n for (flow_id, u, v), split_ratio in F.items() \\n if flow_id == f and u == s and split_ratio > 0.001]\\n return links\",\n \"def set_random_session(self, G, degree_s):\\n sorted_nodes = nx.topological_sort(G)\\n num_nodes = G.number_of_nodes()\\n\\n # create sources and destinations of each of the sections\\n # name the nodes to be the last 4 numbers\\n srcs = [num_nodes, num_nodes + 1]\\n dsts = [num_nodes + 2, num_nodes + 3]\\n\\n end_idx = int(0.3 * len(sorted_nodes))\\n end_idx = max(end_idx, 2)\\n for i in range(2):\\n s = srcs[i]\\n t = dsts[i]\\n reachables = []\\n iter_num = 0\\n\\n while len(reachables) == 0:\\n iter_num += 1\\n if iter_num > 100:\\n end_idx = end_idx * 2\\n\\n # pick an entry point from the first 30%\\n entry_point = random.choice(sorted_nodes[:end_idx])\\n # print \\\"Source \\\", i\\n # print \\\"candidates: \\\", sorted_nodes[:end_idx]\\n # print \\\"entry point: \\\", entry_point\\n # print \\\"all nodes: \\\", G.nodes()\\n\\n # pick a random point from the reachables\\n reachables = nx.shortest_path(G, entry_point)\\n del reachables[entry_point]\\n #print \\\"reachables: \\\", reachables\\n reachables = reachables.keys()\\n\\n exit_point = random.choice(reachables)\\n #print \\\"exit_point: \\\", exit_point\\n\\n if degree_s[i]:\\n G.add_edge(s, entry_point, weight=degree_s[i])\\n G.add_edge(exit_point, t, weight=degree_s[i])\\n else:\\n # figure out the out_degree of entry point\\n out_degree = np.sum(G[u][v]['weight'] for u,v in G.out_edges(entry_point))\\n G.add_edge(s, entry_point, weight=out_degree)\\n\\n # figure out the int_degree of exit point\\n in_degree = np.sum(G[u][v]['weight'] for u,v in G.in_edges(exit_point))\\n G.add_edge(exit_point, t, weight=in_degree)\\n\\n edges = G.edges()\\n for u, v in edges:\\n par_num = int(G[u][v]['weight'])\\n for i in range(par_num):\\n self.add_edge(u, v)\\n\\n # set indices etc\\n self.set_sources(srcs)\\n self.set_destinations(dsts)\\n self.set_indices()\\n #print \\\"number of nodes: \\\" + str(self.number_of_nodes())\\n #print \\\"number of edges: \\\" + str(self.number_of_edges())\",\n \"def __generate_all_shortest_paths(self,cutoff = 10):\\n if cutoff < 1:\\n cutoff = 10\\n self.__logger.info(\\\"cutoff value must be a positive integer. Set back to default value: 10\\\")\\n\\n all_pair_shortest_paths = nx.all_pairs_shortest_path(self.G, cutoff=cutoff)\\n for item in all_pair_shortest_paths:\\n from_node = item[0]\\n paths = item[1]\\n for destination,path in paths.items():\\n yield (len(path),path)\",\n \"def ford_fulkerson_algorithm(graph: np.ndarray, source: int, sink: int) -> np.ndarray:\\r\\n\\r\\n residual_graph = copy.deepcopy(graph)\\r\\n row = len(residual_graph)\\r\\n parent = [-1] * row\\r\\n max_flow = 0\\r\\n\\r\\n if source == sink or sink < 0 or source < 0 or source >= row or sink >= row:\\r\\n raise WrongInputException('Wrong input source/sink vertice(s)')\\r\\n\\r\\n while bfs(residual_graph, row, source, sink, parent):\\r\\n\\r\\n path_flow = float(\\\"Inf\\\")\\r\\n s = sink\\r\\n while s != source:\\r\\n path_flow = min(path_flow, residual_graph[parent[s]][s])\\r\\n s = parent[s]\\r\\n\\r\\n max_flow += path_flow\\r\\n\\r\\n v = sink\\r\\n while v != source:\\r\\n u = parent[v]\\r\\n residual_graph[u][v] -= path_flow\\r\\n residual_graph[v][u] += path_flow\\r\\n v = parent[v]\\r\\n print(\\\"Max flow: %d\\\" % max_flow)\\r\\n\\r\\n return residual_graph\",\n \"def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\\n demand: float,\\n routing: np.ndarray) -> np.ndarray:\\n edge_mapping = {edge: i for i, edge in\\n enumerate(sorted(self.graph.edges))}\\n\\n link_utilisation = np.zeros(self.num_edges)\\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\\n node_flow[flow[0]] = demand\\n\\n to_explore = [flow[0]]\\n while to_explore:\\n current_node = to_explore.pop(0)\\n current_flow = node_flow[current_node]\\n\\n # this is the flow destination node so we absorb all flow\\n if current_node == flow[1]:\\n node_flow[current_node] = 0.0\\n continue\\n\\n # push the flow at this node over all edges\\n for edge in self.graph.out_edges(current_node):\\n edge_index = edge_mapping[edge]\\n ratio = routing[edge_index]\\n flow_to_send = ratio * current_flow\\n # only send flow if greater than epsilon (so no 'infinite' loops)\\n if flow_to_send > 1.e-8:\\n node_flow[edge[1]] += ratio * current_flow\\n # all important step, update our output\\n link_utilisation[edge_index] += ratio * current_flow\\n # have updated the dst so add it to the list of things to do\\n to_explore.append(edge[1])\\n # we've moved all the flow from this node now, so reset back to zero\\n node_flow[current_node] = 0.0\\n\\n return link_utilisation\",\n \"def run_random_annealing(tsp_file, T, scheme, N_sim, max_chain_length=100000, c=.95):\\n # create empty lists for to be stored values\\n best_routes, costs, cost_lists = [], [], []\\n\\n adjacency_matrix = make_matrix(tsp_file)\\n\\n for _ in range(N_sim):\\n # generate random initial route\\n x = list(range(len(adjacency_matrix)))\\n init_route = random.sample(x,len(x))\\n \\n # find best route with SA algorithm\\n best_route, cost_list = tsp_annealing_random(T, scheme, init_route, adjacency_matrix, max_chain_length, c)\\n\\n # append all values from simulation to lists\\n costs.append(calculate_cost(best_route,adjacency_matrix)[1])\\n best_routes.append(best_route)\\n cost_lists.append(cost_list)\\n\\n return best_routes, costs, cost_lists\",\n \"def stochastic_event_set(\\n sources, source_site_filter=filters.source_site_noop_filter):\\n for source, s_sites in source_site_filter(sources):\\n try:\\n for rupture in source.iter_ruptures():\\n for i in range(rupture.sample_number_of_occurrences()):\\n yield rupture\\n except Exception as err:\\n etype, err, tb = sys.exc_info()\\n msg = 'An error occurred with source id=%s. Error: %s'\\n msg %= (source.source_id, str(err))\\n raise_(etype, msg, tb)\",\n \"def sampled_clique(clusters,strategy):\\n G = nx.Graph()\\n sample = []\\n #Sample 'size' nodes from a single cluster\\n if strategy == \\\"rand\\\":\\n size = len(clusters)\\n while len(sample) < size:\\n cluster = random.choice(clusters)\\n if len(cluster) >= size:\\n sample = random.sample(cluster,size)\\n #Sample 1 choice from each cluster\\n elif strategy == \\\"optim\\\":\\n for _,cluster in clusters.items():\\n if len(cluster) > 0:\\n sample.append(random.choice(cluster))\\n for n1 in sample:\\n for n2 in sample:\\n if n1 != n2:\\n G.add_edge(n1,n2)\\n return G\",\n \"def get_k_shortest_paths(env: RailEnv,\\n source_position: Tuple[int, int],\\n source_direction: int,\\n target_position=Tuple[int, int],\\n k: int = 1, debug=False) -> List[Tuple[Waypoint]]:\\n\\n # P: set of shortest paths from s to t\\n # P =empty,\\n shortest_paths: List[Tuple[Waypoint]] = []\\n\\n # countu: number of shortest paths found to node u\\n # countu = 0, for all u in V\\n count = {(r, c, d): 0 for r in range(env.height) for c in range(env.width) for d in range(4)}\\n\\n # B is a heap data structure containing paths\\n # N.B. use OrderedSet to make result deterministic!\\n heap: OrderedSet[Tuple[Waypoint]] = OrderedSet()\\n\\n # insert path Ps = {s} into B with cost 0\\n heap.add((Waypoint(source_position, source_direction),))\\n\\n # while B is not empty and countt < K:\\n while len(heap) > 0 and len(shortest_paths) < k:\\n if debug:\\n print(\\\"iteration heap={}, shortest_paths={}\\\".format(heap, shortest_paths))\\n # – let Pu be the shortest cost path in B with cost C\\n cost = np.inf\\n pu = None\\n for path in heap:\\n if len(path) < cost:\\n pu = path\\n cost = len(path)\\n u: Waypoint = pu[-1]\\n if debug:\\n print(\\\" looking at pu={}\\\".format(pu))\\n\\n # – B = B − {Pu }\\n heap.remove(pu)\\n # – countu = countu + 1\\n\\n urcd = (*u.position, u.direction)\\n count[urcd] += 1\\n\\n # – if u = t then P = P U {Pu}\\n if u.position == target_position:\\n if debug:\\n print(\\\" found of length {} {}\\\".format(len(pu), pu))\\n shortest_paths.append(pu)\\n\\n # – if countu ≤ K then\\n # CAVEAT: do not allow for loopy paths\\n elif count[urcd] <= k:\\n possible_transitions = env.rail.get_transitions(*urcd)\\n if debug:\\n print(\\\" looking at neighbors of u={}, transitions are {}\\\".format(u, possible_transitions))\\n # for each vertex v adjacent to u:\\n for new_direction in range(4):\\n if debug:\\n print(\\\" looking at new_direction={}\\\".format(new_direction))\\n if possible_transitions[new_direction]:\\n new_position = get_new_position(u.position, new_direction)\\n if debug:\\n print(\\\" looking at neighbor v={}\\\".format((*new_position, new_direction)))\\n\\n v = Waypoint(position=new_position, direction=new_direction)\\n # CAVEAT: do not allow for loopy paths\\n if v in pu:\\n continue\\n\\n # – let Pv be a new path with cost C + w(u, v) formed by concatenating edge (u, v) to path Pu\\n pv = pu + (v,)\\n # – insert Pv into B\\n heap.add(pv)\\n\\n # return P\\n return shortest_paths\",\n \"def test_heuristic_first_steps(self):\\n graph = {n: set(self.deterministic_graph[n]) - set([n])\\n for n in self.deterministic_graph}\\n deg_heuristic = MinDegreeHeuristic(graph)\\n elim_node = deg_heuristic.best_node(graph)\\n print(\\\"Graph {}:\\\".format(graph))\\n steps = []\\n\\n while elim_node is not None:\\n print(\\\"Removing {}:\\\".format(elim_node))\\n steps.append(elim_node)\\n nbrs = graph[elim_node]\\n\\n for u, v in itertools.permutations(nbrs, 2):\\n if v not in graph[u]:\\n graph[u].add(v)\\n\\n for u in graph:\\n if elim_node in graph[u]:\\n graph[u].remove(elim_node)\\n\\n del graph[elim_node]\\n print(\\\"Graph {}:\\\".format(graph))\\n elim_node = deg_heuristic.best_node(graph)\\n\\n # check only the first 5 elements for equality\\n assert_equals(steps[:5], [0, 1, 2, 3, 4])\",\n \"def _compute_flows(paths):\\n assert isinstance(paths, list)\\n\\n # allocate memory\\n flows = np.zeros([len(paths), FLAGS.target_height, FLAGS.target_width, 2],\\n dtype=np.float32)\\n\\n # load all images\\n pbar = ProgressBar(max_value=len(paths))\\n for i in range(len(paths)-1):\\n im1 = skimage.io.imread(paths[i])\\n im2 = skimage.io.imread(paths[i+1])\\n\\n im1 = cv2.cvtColor(im1, cv2.COLOR_RGB2GRAY)\\n im2 = cv2.cvtColor(im2, cv2.COLOR_RGB2GRAY)\\n im1 = skimage.transform.resize(\\n im1, [FLAGS.target_height, FLAGS.target_width], preserve_range=True,\\n mode='constant', anti_aliasing=True)\\n im2 = skimage.transform.resize(\\n im2, [FLAGS.target_height, FLAGS.target_width], preserve_range=True,\\n mode='constant', anti_aliasing=True)\\n flow = cv2.calcOpticalFlowFarneback(\\n im1, im2, flow=None, pyr_scale=0.5, levels=3, winsize=15,\\n iterations=3, poly_n=5, poly_sigma=1.2, flags=0)\\n\\n # store images\\n flows[i] = flow\\n pbar.update(i)\\n\\n # Replicate the flow for last frame\\n flows[-1] = flow\\n return flows\",\n \"def random_partition_graph(groups, p_in, p_out, seed=None):\\r\\n\\r\\n if p_in > 1 or p_in < 0:\\r\\n raise errorhandler.ErrorHandler(\\\"p_in must be in [0,1]\\\")\\r\\n\\r\\n if p_out > 1 or p_out < 0:\\r\\n raise errorhandler.ErrorHandler(\\\"p_out must be in [0,1]\\\")\\r\\n\\r\\n size = sum(groups)\\r\\n g = graph.Graph(size, is_partition=True)\\r\\n\\r\\n next_group = {}\\r\\n start = 0\\r\\n group_index = 0\\r\\n for n in groups: # connect nodes inside a group\\r\\n edges = ((u + start, v + start) for u, v in fast_random_graph(n, p_in).edges)\\r\\n g.add_edges(edges)\\r\\n g.partition.append(set(range(start, start+n)))\\r\\n next_group.update(dict.fromkeys(range(start, start + n), start + n))\\r\\n group_index += 1\\r\\n start += n\\r\\n\\r\\n # connect nodes between groups\\r\\n if p_out == 0:\\r\\n return g\\r\\n if p_out == 1:\\r\\n for n in next_group:\\r\\n targets = range(next_group[n], len(g))\\r\\n g.add_edges(zip([n] * len(targets), targets))\\r\\n return g\\r\\n\\r\\n # using method similar to fast_random_graph\\r\\n lp = math.log(1.0 - p_out)\\r\\n n = len(g)\\r\\n\\r\\n for u in range(n - 1):\\r\\n v = next_group[u]\\r\\n while v < n:\\r\\n lr = math.log(1.0 - random.random())\\r\\n v += int(lr / lp)\\r\\n if v < n:\\r\\n g.add_edge(u, v)\\r\\n v += 1\\r\\n\\r\\n return g\",\n \"def get_routing_solution(self):\\n G = self.base_digraph\\n s1 = self.sources[0]\\n s2 = self.sources[1]\\n t1 = self.destinations[0]\\n t2 = self.destinations[1]\\n\\n try:\\n m = Model('routing')\\n m.setParam('OutputFlag', False)\\n\\n # variables,\\n # We have one variable per edge per session\\n # e is the dict of dict for the variables\\n e = {}\\n r = {}\\n for i in [1,2]:\\n e[i] = {}\\n r[i] = m.addVar()\\n for u,v in G.edges():\\n e[i][u,v] = m.addVar(lb=0)\\n\\n m.update()\\n\\n obj = quicksum(r.values())\\n m.setObjective(obj, GRB.MAXIMIZE)\\n\\n # constraints\\n # 1. conservations of flow at all intermediate nodes\\n # 2. capacity constraints for each edge\\n\\n for u,v in G.edges():\\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\\n\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\\n\\n for n in G.nodes():\\n if n not in [s1, s2, t1, t2]:\\n for i in [1, 2]:\\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\\n m.addConstr(inflow == outflow)\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n for u, v in G.edges():\\n G[u][v]['Routing'] = {}\\n G[u][v]['Routing'][1] = e[1][u,v].x\\n G[u][v]['Routing'][2] = e[2][u,v].x\\n return (m.objVal, r[1].x, r[2].x)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong, no optimal solution obtained\\\"\\n return None, None, None\\n\\n except GurobiError:\\n Print ('Error Report from Gurobi')\",\n \"def shuffle(self) -> NoReturn:\\n for edge_type in self.edge_types:\\n for edge_class in range(self.edge_types[edge_type]):\\n self.train_edges[edge_type][edge_class] = np.random.permutation(\\n self.train_edges[edge_type][edge_class])\\n\\n self.freebatch_edge_types = {edge_type: list(range(edge_class))\\n for edge_type, edge_class in self.edge_types.items()}\\n self.batch_num = {edge_type: [0] * edge_class for edge_type, edge_class in\\n self.edge_types.items()}\\n self.took_all_edges = {edge_type: False for edge_type in self.edge_types}\\n self.iter = 0\",\n \"def get_random_depth_sample(n=8, depths=list(range(2,26,2)), num_samples=100):\\n\\n def get_states(start):\\n frontier = [start]\\n frontier_set = {start}\\n explored = set()\\n\\n states = [False for _ in range(len(depths))]\\n while not all(states):\\n node = frontier.pop(0)\\n frontier_set.remove(node)\\n explored.add(node)\\n\\n children = node.get_children()\\n\\n # It's necessary to shuffle children to get a truly random sample; otherwise, the first child (always\\n # produced from the parent by the same action) produced at a certain depth will always be selected,\\n # and children produced by other actions will never be selected\\n shuffle(children)\\n\\n for child in children:\\n if child not in frontier_set and child not in explored:\\n frontier_set.add(child)\\n frontier.append(child)\\n child.path_cost = node.path_cost+1\\n index = depths.index(child.path_cost) if child.path_cost in depths else None\\n if index is not None and not states[index]:\\n states[index] = {'start': start.sequence, 'end': child.sequence}\\n\\n return states\\n\\n depth_sample = [[] for depth in range(len(depths))]\\n\\n for _ in range(num_samples):\\n start = list(range(1,n+2))\\n shuffle(start)\\n start = PuzzleState(start, path_cost=0)\\n\\n states = get_states(start)\\n print('\\\\rSet ' + str(_+1) + ' of ' + str(num_samples) + ' complete', end='', flush=True)\\n list(map(list.append, depth_sample, states))\\n\\n return depth_sample\",\n \"def tsp_annealing_random(T, scheme, route, adjacency_matrix, max_chain_length,c):\\n best = route.copy()\\n chains = 0\\n cost_list = []\\n T_0 = T\\n T_list = []\\n \\n while T > 0:\\n # Sample city from route\\n temp = route.copy()\\n index1, index2 = np.random.randint(1,len(best)-1,size=2)\\n\\n sd, cost0 = calculate_cost(route,adjacency_matrix)\\n cost_list.append(cost0)\\n\\n temp[index1:index2] = temp[index2-1:index1-1:-1]\\n _, cost1 = calculate_cost(temp,adjacency_matrix)\\n\\n chains += 1\\n T_list.append(T)\\n\\n # Adjust temperature\\n if scheme == \\\"exp\\\":\\n T = T*c\\n if scheme == \\\"log\\\":\\n alpha = 50\\n T = T_0/(1+alpha*np.log(1+chains))\\n if scheme == \\\"std\\\":\\n delta = .1\\n T = T / (1 + ((np.log(1+delta)* T) / (3 * sd)))\\n if scheme == \\\"quad\\\":\\n alpha = 1\\n T = T_0/(1+alpha*chains**2)\\n\\n # Metropolis step \\n if cost0 > cost1:\\n route = temp.copy()\\n else:\\n U = rs.uniform()\\n if U < np.exp((cost0-cost1)/T):\\n route = temp.copy()\\n\\n best = route.copy()\\n if chains > max_chain_length:\\n return best, cost_list\\n return best, cost_list\",\n \"def _dfs(\\n self, kg: KG, entity: Vertex, is_reverse: bool = False\\n ) -> List[Walk]:\\n self.sampler.visited = set()\\n walks: List[Walk] = []\\n assert self.max_walks is not None\\n\\n rng = np.random.RandomState(self.random_state)\\n\\n while len(walks) < self.max_walks:\\n sub_walk: Walk = (entity,)\\n d = 1\\n while d // 2 < self.max_depth:\\n pred_obj = self.sampler.sample_hop(\\n kg, sub_walk, d // 2 == self.max_depth - 1, is_reverse\\n )\\n if pred_obj is None:\\n break\\n\\n if is_reverse:\\n if (\\n pred_obj[0] in self.communities\\n and rng.random() < self.hop_prob\\n ):\\n community_nodes = self.labels_per_community[\\n self.communities[pred_obj[0]]\\n ]\\n sub_walk = (\\n pred_obj[1],\\n rng.choice(community_nodes),\\n ) + sub_walk\\n else:\\n sub_walk = (pred_obj[1], pred_obj[0]) + sub_walk\\n else:\\n if (\\n pred_obj[1] in self.communities\\n and rng.random() < self.hop_prob\\n ):\\n community_nodes = self.labels_per_community[\\n self.communities[pred_obj[1]]\\n ]\\n sub_walk += (\\n pred_obj[0],\\n rng.choice(community_nodes),\\n )\\n else:\\n sub_walk += (pred_obj[0], pred_obj[1])\\n d = len(sub_walk) - 1\\n walks.append(sub_walk)\\n return list(walks)\",\n \"def update_flow(self):\\n N = len(self.vertices)\\n _vertices = self.vertices+['_source', '_sink']\\n s, t = _vertices.index('_source'), _vertices.index('_sink')\\n cost, capacity = dok_matrix((N+2, N+2)), dok_matrix((N+2, N+2))\\n\\n cost[:N, :N] = self.cost\\n capacity[:N, :N] = self.upper_bound-self.lower_bound\\n # _source to main vertices\\n l_in = self.lower_bound.toarray().sum(axis=0)\\n us, = l_in.nonzero()\\n for u in us:\\n capacity[s, u] = l_in[u]\\n # main vertices to _sink\\n l_out = self.lower_bound.toarray().sum(axis=1)\\n us, = l_out.nonzero()\\n for u in us:\\n capacity[u, t] = l_out[u]\\n # sink to source\\n infinite_flow = self.upper_bound.toarray().sum()\\n capacity[_vertices.index('sink'), _vertices.index('source')] = infinite_flow\\n\\n # get a feasible flow on original graph by finding the max flow on\\n # auxiliary graph\\n aux_fg = FlowGraph(_vertices, cost, capacity, True)\\n aux_fg.FordFulkerson()\\n assert aux_fg.residual[s].toarray().sum()==0, 'feasible flow within bounds not found'\\n\\n self.residual = aux_fg.residual[:N, :N]\\n s, t = self.vertices.index('source'), self.vertices.index('sink')\\n self.residual[s, t] = 0\\n self.residual[t, s] = 0\\n\\n self.FordFulkerson()\",\n \"def test_heuristic_first_steps(self):\\n graph = {n: set(self.deterministic_graph[n]) - set([n])\\n for n in self.deterministic_graph}\\n print(\\\"Graph {}:\\\".format(graph))\\n elim_node = min_fill_in_heuristic(graph)\\n steps = []\\n\\n while elim_node is not None:\\n print(\\\"Removing {}:\\\".format(elim_node))\\n steps.append(elim_node)\\n nbrs = graph[elim_node]\\n\\n for u, v in itertools.permutations(nbrs, 2):\\n if v not in graph[u]:\\n graph[u].add(v)\\n\\n for u in graph:\\n if elim_node in graph[u]:\\n graph[u].remove(elim_node)\\n\\n del graph[elim_node]\\n print(\\\"Graph {}:\\\".format(graph))\\n elim_node = min_fill_in_heuristic(graph)\\n\\n # check only the first 2 elements for equality\\n assert_equals(steps[:2], [6, 5])\",\n \"def randnet(G):\\n\\t\\n\\t#initializationo of the lists\\n\\telst = G.get_edgelist()\\n\\tclst = G.es['color'][:]\\n\\tcdic = {}\\n\\tfor i,c in enumerate(clst):\\n\\t\\tcdic[c]=i\\n\\tlst1 = [[]]*len(key)\\n\\tfor i,e in enumerate(elst):\\n\\t\\tlst1[cdic[clst[i]]].append([e[0],e[1]])\\n\\t\\t\\n\\t#randomization procedure\\n\\tfor i in range(random.randrange(100,200)):\\n\\t\\tcid = cdic[random.choice(clst)] #random choice weighted by the frequency of each color\\n\\t\\te1id = random.randrange(0,len(lst1[cid])) #random choice of edge with that color\\n\\t\\te2id = random.randrange(0,len(lst1[cid]))\\n\\t\\textop = random.randrange(0,2)#random choice of top/bottom\\n\\t\\tttemp = lst1[cid][e1id][extop]\\n\\t\\tlst1[cid][e1id][extop] = lst1[cid][e2id][extop]\\n\\t\\tlst1[cid][e2id][extop] = ttemp\\n\\t\\n\\tcoutlst = []\\n\\teoutlst\\t= []\\n\\tfor i in range(len(lst1)):\\n\\t\\tc = clst[i]\\n\\t\\tfor e in lst1[i]:\\n\\t\\t\\tcoutlst.append(c)\\n\\t\\t\\teoutlst.append((e[0],e[1]))\\n\\n\\treturn [eoutlst,coutlst]\",\n \"def get_weight_from_minflow(self):\\n start_nodes = []\\n end_nodes = []\\n capacities = []\\n unit_costs = []\\n A = 0\\n s_prime = self.sink() + 1\\n t_prime = self.sink() + 2\\n x = self.sink() + 3\\n # for every edge in the graph, add edge to mincost flow instance with\\n # infinite capacity and cost 1\\n # also add backwards edge\\n for arc in self.arc_info.keys():\\n # forward edge\\n start_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"start\\\"],\\n self.arc_info[arc][\\\"destin\\\"]))\\n # backward edge\\n start_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n capacities.append(int(self.arc_info[arc][\\\"weight\\\"])) # no negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"destin\\\"],\\n self.arc_info[arc][\\\"start\\\"]))\\n # add (x,s) and (t,x) edges with same cap, cost as above\\n in_weight_x = 0\\n for in_arc in self.in_arcs_lists[self.sink()]:\\n in_weight_x += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight_x = 0\\n for out_arc in self.out_arcs_lists[self.source()]:\\n out_weight_x += self.arc_info[out_arc][\\\"weight\\\"]\\n # (x,s)\\n start_nodes.append(x)\\n end_nodes.append(self.source())\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.source()))\\n # backward\\n start_nodes.append(self.source())\\n end_nodes.append(x)\\n capacities.append(int(out_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.source(),\\n x))\\n # (t,x)\\n start_nodes.append(self.sink())\\n end_nodes.append(x)\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.sink(),\\n x))\\n # backward\\n start_nodes.append(x)\\n end_nodes.append(self.sink())\\n capacities.append(int(in_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.sink()))\\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\\n # and cost 0.\\n for v in self:\\n # process internal verts only, since we assume source and sink have\\n # no in and out edges respectively\\n if v != self.source() and v != self.sink():\\n # compute a-exc(v)\\n in_weight = 0\\n for in_arc in self.in_arcs_lists[v]:\\n in_weight += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight = 0\\n for out_arc in self.out_arcs_lists[v]:\\n out_weight += self.arc_info[out_arc][\\\"weight\\\"]\\n a_exc = out_weight - in_weight\\n if a_exc < 0:\\n # add edge (s', v)\\n start_nodes.append(s_prime)\\n end_nodes.append(v)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n v,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (v, t')\\n start_nodes.append(v)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n v,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # process x node\\n a_exc = out_weight_x - in_weight_x\\n if a_exc < 0:\\n # add edge (s', x)\\n start_nodes.append(s_prime)\\n end_nodes.append(x)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n x,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (x, t')\\n start_nodes.append(x)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n x,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # we must send flow of A from s_prime to t_prime\\n supplies = [0]*(len(self) + 3)\\n supplies[s_prime] = int(A)\\n supplies[t_prime] = int(-A)\\n # Instantiate a SimpleMinCostFlow solver.\\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\\n # Add each arc.\\n for i in range(len(start_nodes)):\\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\\n end_nodes[i], capacities[i], unit_costs[i])\\n # Add node supplies\\n for i in range(0, len(supplies)):\\n min_cost_flow.SetNodeSupply(i, supplies[i])\\n # Find the minimum cost flow between node s' and t'.\\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\\n print('Minimum cost:', min_cost_flow.OptimalCost())\\n print('')\\n print(' Arc Flow / Capacity Cost')\\n for i in range(min_cost_flow.NumArcs()):\\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\\n print('%1s -> %1s %3s / %3s %3s' % (\\n min_cost_flow.Tail(i),\\n min_cost_flow.Head(i),\\n min_cost_flow.Flow(i),\\n min_cost_flow.Capacity(i),\\n cost))\\n # update arcs\\n start = min_cost_flow.Tail(i)\\n destin = min_cost_flow.Head(i)\\n if start != s_prime and \\\\\\n start != t_prime and \\\\\\n start != x and \\\\\\n destin != s_prime and \\\\\\n destin != t_prime and \\\\\\n destin != x:\\n # if forward, increase flow. otherwise decrease.\\n print(\\\"Processing edge ({}, {})\\\".format(start, destin))\\n if start < destin:\\n sup_flow = min_cost_flow.Flow(i)\\n else:\\n sup_flow = -min_cost_flow.Flow(i)\\n temp_start = start\\n start = destin\\n destin = temp_start\\n print(\\\"Has become ({}, {}) with sup {}\\\".format(start,\\n destin,\\n sup_flow))\\n arc = self.get_arc(start, destin)\\n if (sup_flow != 0) or (\\\"lower_bound\\\" not in \\\\\\n self.arc_info[arc].keys()):\\n print(\\\"We should add this\\\")\\n old_flow = self.arc_info[arc][\\\"weight\\\"]\\n new_flow = old_flow + sup_flow\\n self.arc_info[arc][\\\"weight\\\"] = int(new_flow)\\n print(\\\"Edge ({},{}) weight is changed from {} to {}\\\".format(\\n start,\\n destin,\\n old_flow,\\n new_flow))\\n else:\\n print('There was an issue with the min cost flow input.')\\n #self.check_conservation_of_flow() # check that solution is valid\",\n \"def get_flows(self, num_flows_per_entry):\\n flows = []\\n for tenant in self._tenants:\\n for contract in tenant.get_children(only_class=Contract):\\n providing_epgs = contract.get_all_providing_epgs()\\n consuming_epgs = contract.get_all_consuming_epgs()\\n for providing_epg in providing_epgs:\\n vlan_ifs = providing_epg.get_all_attached(L2Interface)\\n if len(vlan_ifs):\\n providing_vlan = vlan_ifs[0].encap_id\\n phys_ifs = vlan_ifs[0].get_all_attached(Interface)\\n if len(phys_ifs):\\n providing_phys_if = phys_ifs[0].name\\n for consuming_epg in consuming_epgs:\\n vlan_ifs = consuming_epg.get_all_attached(L2Interface)\\n if len(vlan_ifs):\\n consuming_vlan = vlan_ifs[0].encap_id\\n phys_ifs = vlan_ifs[0].get_all_attached(Interface)\\n if len(phys_ifs):\\n consuming_phys_if = phys_ifs[0].name\\n if providing_vlan == consuming_vlan and providing_phys_if == consuming_phys_if:\\n # Skip this case since traffic would be switched outside fabric\\n continue\\n for filter_entry in contract.get_all_filter_entries():\\n for i in range(0, num_flows_per_entry):\\n flow = Flow()\\n flow.ethertype = filter_entry.etherT\\n if flow.ethertype == 'arp':\\n flow.arp_opcode = filter_entry.arpOpc\\n flow.populate_random_ip_addresses()\\n elif flow.ethertype == 'ip':\\n flow.populate_random_ip_addresses()\\n flow.proto = filter_entry.prot\\n if flow.proto == '6' or flow.proto == '17':\\n dFromPort = int(filter_entry.dFromPort)\\n dToPort = int(filter_entry.dToPort)\\n sFromPort = int(filter_entry.sFromPort)\\n sToPort = int(filter_entry.sToPort)\\n if dFromPort == 0:\\n dFromPort = 1\\n dToPort += 1\\n if sFromPort == 0:\\n sFromPort = 1\\n sToPort += 1\\n if dToPort > 65534:\\n dToPort = 65534\\n if sToPort > 65534:\\n sToPort = 65534\\n flow.dport = str(random_number(dFromPort,\\n dToPort))\\n flow.sport = str(random_number(sFromPort,\\n sToPort))\\n if flow.proto == '6':\\n flow.tcp_rules = filter_entry.tcpRules\\n flow.svlan = providing_vlan\\n flow.dvlan = consuming_vlan\\n flow.src_intf = providing_phys_if\\n flow.dst_intf = consuming_phys_if\\n\\n # Is the flow expected to succeed ?\\n flow.expected_action = 'drop'\\n providing_bd = providing_epg.get_bd()\\n consuming_bd = consuming_epg.get_bd()\\n if providing_bd and consuming_bd:\\n if providing_bd == consuming_bd:\\n if providing_bd.get_context() == consuming_bd.get_context():\\n flow.expected_action = 'permit'\\n flow.populate_random_mac_addresses()\\n flows.append(flow)\\n return flows\",\n \"def test_sources():\\n g = Graph(from_list=[\\n (1, 3, 1),\\n (2, 4, 1),\\n (2, 5, 1),\\n (3, 5, 1),\\n (4, 6, 1),\\n (5, 6, 1),\\n ])\\n g.add_node(7)\\n s = g.sources(5)\\n e = {1, 2, 3}\\n assert s == e\\n\\n s2 = g.sources(1)\\n e2 = set()\\n assert s2 == e2, s2\\n\\n s3 = g.sources(6)\\n e3 = {1, 2, 3, 4, 5}\\n assert s3 == e3\\n\\n s4 = g.sources(7)\\n e4 = set()\\n assert s4 == e4\",\n \"def max_flow(self, source, sink):\\n\\n path = self.valid_path(source, sink, [])\\n\\n while path:\\n # get the maximum possible flow that can be taken from this path:\\n max_flow = min([edge.capacity for edge in path])\\n for edge in path:\\n self.edges[edge] += max_flow\\n path = self.valid_path(source, sink, [])\\n\\n # Compute all the flows from the neighbors of source:\\n return sum([self.edges[edge] for edge in self.adjacents[source]])\",\n \"def gen_task_sets_fairgen(nsets):\\n start = time()\\n eval_task_sets = []\\n for util in utils:\\n task_sets = []\\n for i in range(nsets):\\n ts = synth.mc_fairgen(set_id=i, u_lo=util, implicit_deadlines=True)\\n synth.synth_c_pmf(ts)\\n synth.set_fixed_priorities(ts)\\n task_sets.append(ts)\\n eval_task_sets.append(task_sets)\\n stop = time()\\n print('Task Set Generation MC-Fairgen: %.3fs' % (stop - start))\\n pickle.dump(eval_task_sets, open(task_sets_path + 'task_sets_fairgen', 'wb'))\",\n \"def run_destination_reduction(self):\\n s = self.sources\\n t = self.destinations\\n\\n # get the union set of source edges\\n s_edges = [self.out_edges(x) for x in s]\\n s_edges_idx = [set(self.get_edges_indices(src)) for src in s_edges]\\n S = set.union(*s_edges_idx)\\n\\n # now starting from the sources\\n T_curr = [set(self.in_edges(x)) for x in t]\\n T_curr_idx = [set(self.get_edges_indices(x)) for x in T_curr]\\n T_union = set.union(*[set(x) for x in T_curr])\\n T_union_idx = set.union(*T_curr_idx)\\n self.dst_evolution_rec = [T_curr_idx]\\n\\n while not T_union_idx.issubset(S):\\n # get the edges out of the max-ordered node\\n tail_nodes = set([x[0] for x in T_union])\\n tail_nodes = tail_nodes - set(s)\\n v = max(tail_nodes, key=lambda p: self.node[p]['index'])\\n\\n E = set([edge for edge in T_union if edge[0] == v])\\n E_curr = [x.intersection(E) for x in T_curr]\\n\\n T_next = []\\n Uv = self.in_edges(v)\\n for (Ex, Tx) in zip(E_curr, T_curr):\\n if Ex:\\n T_next.append((Tx - Ex).union(Uv))\\n else:\\n T_next.append(Tx)\\n\\n T_curr = T_next\\n T_curr_idx = [set(self.get_edges_indices(x)) for x in T_curr]\\n self.dst_evolution_rec.append(T_curr_idx)\\n\\n T_union = set.union(*[set(x) for x in T_curr])\\n T_union_idx = set.union(*T_curr_idx)\",\n \"def objective(graph, flows):\\n\\n G = graph.copy()\\n rules = {}\\n flows.sort(key=lambda a: a[1], reverse=True)\\n\\n for flow,demand in flows:\\n src = get_host_from_ip(G, flow.nw_src)\\n dst = get_host_from_ip(G, flow.nw_dst)\\n\\n if not (src and dst):\\n continue\\n if not (src in G.nodes() and dst in G.nodes()):\\n continue\\n\\n path = widest_path(G, src, dst)\\n\\n hops = []\\n for a,b in pairwise(path):\\n hops.append(Hop(dpid=int(a[1:]), port=G.edge[a][b]['port']))\\n G.edge[a][b]['capacity'] -= demand\\n G.edge[b][a]['capacity'] -= demand\\n\\n rules[flow] = hops\\n\\n return rules\",\n \"def _select_destination(self):\\n # Ideally this should do something clever based on the start location\\n # ie known trips. But for now, it will pick randomly!\\n station_dict = self.network.station_dict\\n\\n stations = list(station_dict.keys())\\n #stations = [x for x in stations if isinstance(x, int) or x.startswith(\\\"801\\\")]\\n #stations = [x for x in stations if isinstance(x, int) or x.startswith(\\\"80139\\\")]\\n weights = [station_dict[x].in_popularity for x in stations]\\n\\n # pick using the given weight distributions\\n self.dest = random.choices(stations, weights=weights)[0]\\n\\n return\",\n \"def multipleTravellingSalesmen2(self, iterations=None):\\n if not iterations:\\n iterations = self.mTSPIterations\\n\\n paths, self.totaldistanceMTSP = self.greedyMultiplePaths(self.ships)\\n\\n # Run single travelling salesman on each of the ships\\n paths = [self.singleTravellingSalesman2(path, iterations=5000) for path in paths]\\n\\n # IF TWO OR MORE SHIPS!!!\\n # Point exchange between ships and rerun tsp on each ship\\n if len(self.ships) > 1:\\n for _ in range(iterations):\\n twopathindices = random.sample(xrange(len(paths)), 2)\\n if min([len(path) for path in paths]) > 1:\\n newtwopaths = self.swapTwoPointsBetweenPaths([paths[index] for index in twopathindices])\\n newtwopaths = [self.singleTravellingSalesman2(path, iterations=100) for path in newtwopaths]\\n if self.totalPathDistance(newtwopaths) < self.totalPathDistance([paths[index] for index in twopathindices]):\\n for i, index in enumerate(twopathindices):\\n paths[index] = newtwopaths[i]\\n\\n return [path[::-1] for path in paths]\\n\\n # Might be a simple tsp whereby the new points search for the twp closest points and\\n # inserts between them on the path\",\n \"def __generate_random_nodes(self,k=3):\\n if k < 3:\\n k = 3\\n\\n k = min(k,len(self.G.nodes()))\\n self.__logger.info(\\\"RANDOM_NODES: try to generate a set of {} nodes sampled with uniform distribution\\\".format(k))\\n \\n return random.sample(self.G.nodes(),k)\",\n \"def __dynamicThroughput( self, sourceSEs, destSEs ):\\n res = self.__getTimeToStart()\\n if not res['OK']:\\n gLogger.error( res['Message'] )\\n return {}\\n channelInfo = res['Value']\\n\\n timeToSite = {} # Maintains time to site including previous hops\\n siteAncestor = {} # Maintains the ancestor channel for a site\\n tree = {} # Maintains replication tree\\n while len( destSEs ) > 0:\\n minTotalTimeToStart = float( \\\"inf\\\" )\\n candidateChannels = []\\n sourceActiveSEs = self.__getActiveSEs( sourceSEs )\\n for destSE in destSEs:\\n destSites = self.__getChannelSitesForSE( destSE )\\n localTransfer = False\\n for destSite in destSites:\\n if localTransfer: break\\n for sourceSE in sourceActiveSEs:\\n if localTransfer: break\\n sourceSites = self.__getChannelSitesForSE( sourceSE )\\n for sourceSite in sourceSites:\\n if localTransfer: break\\n channelName = '%s-%s' % ( sourceSite, destSite )\\n if channelInfo.has_key( channelName ):\\n channelID = channelInfo[channelName]['ChannelID']\\n if tree.has_key( channelID ):\\n continue\\n channelTimeToStart = channelInfo[channelName]['TimeToStart']\\n if timeToSite.has_key( sourceSE ):\\n totalTimeToStart = timeToSite[sourceSE] + channelTimeToStart + self.sigma\\n else:\\n totalTimeToStart = channelTimeToStart\\n #print '%s-%s %s %s' % (sourceSE,destSE,channelTimeToStart,totalTimeToStart)\\n localTransfer = ( sourceSite == destSite )\\n if localTransfer or totalTimeToStart < minTotalTimeToStart:\\n minTotalTimeToStart = totalTimeToStart\\n selectedPathTimeToStart = totalTimeToStart\\n candidateChannels = [( sourceSE, destSE, channelID )]\\n elif totalTimeToStart == minTotalTimeToStart:\\n candidateChannels.append( ( sourceSE, destSE, channelID ) )\\n\\n #minTotalTimeToStart = totalTimeToStart\\n #selectedPathTimeToStart = totalTimeToStart\\n #selectedSourceSE = sourceSE\\n #selectedDestSE = destSE\\n #selectedChannelID = channelID\\n else:\\n errStr = 'StrategyHandler.__dynamicThroughput: Channel not defined'\\n gLogger.warn( errStr, channelName )\\n\\n #print 'Selected %s \\\\n' % selectedPathTimeToStart\\n\\n random.shuffle( candidateChannels )\\n selectedSourceSE, selectedDestSE, selectedChannelID = candidateChannels[0]\\n timeToSite[selectedDestSE] = selectedPathTimeToStart\\n siteAncestor[selectedDestSE] = selectedChannelID\\n\\n if siteAncestor.has_key( selectedSourceSE ):\\n waitingChannel = siteAncestor[selectedSourceSE]\\n else:\\n waitingChannel = False\\n tree[selectedChannelID] = {}\\n tree[selectedChannelID]['Ancestor'] = waitingChannel\\n tree[selectedChannelID]['SourceSE'] = selectedSourceSE\\n tree[selectedChannelID]['DestSE'] = selectedDestSE\\n tree[selectedChannelID]['Strategy'] = 'DynamicThroughput'\\n sourceSEs.append( selectedDestSE )\\n destSEs.remove( selectedDestSE )\\n return tree\",\n \"def shuffle(self):\\n for edge_type in self.edge_types:\\n for k in range(self.edge_types[edge_type]):\\n self.train_edges[edge_type][k] = np.random.permutation(self.train_edges[edge_type][k])\\n self.batch_num[self.edge_type2idx[edge_type[0], edge_type[1], k]] = 0\\n self.current_edge_type_idx = 0\\n self.freebatch_edge_types = list(range(self.num_edge_types))\\n self.freebatch_edge_types.remove(self.edge_type2idx[0, 0, 0])\\n self.freebatch_edge_types.remove(self.edge_type2idx[0, 1, 0])\\n self.freebatch_edge_types.remove(self.edge_type2idx[1, 0, 0])\\n self.iter = 0\",\n \"def randomNetwork(self, numVertices, numEdges, capacityRange):\\r\\n for _ in range(numEdges):\\r\\n fromVertex, toVertex = None, None\\r\\n while fromVertex == toVertex or (fromVertex, toVertex) in self.capacity:\\r\\n fromVertex = randint(1, numVertices)\\r\\n toVertex = randint(1, numVertices)\\r\\n capacity = randint(1, capacityRange) \\r\\n self.addEdge(fromVertex, toVertex, capacity)\",\n \"def configuration_model(g, kmin, kmax, size, c, offset):\\n # Makes sure that networks have an even number of half-edges, since\\n # the number of half-edges prepared for linking can be uneven.\\n its = inverse_transform_sampling(g, kmin, kmax, size, offset)\\n sum_its = sum(its)\\n while sum_its % 2 != c % 2:\\n its = inverse_transform_sampling(g, kmin, kmax, size, offset)\\n sum_its = sum(its)\\n\\n # Brings the dist. seq. into the half-edge form,\\n # e.g. [1,2,3] -> [0,1,1,2,2,2]\\n seq = []\\n k = 0\\n for i in range(size):\\n for j in range(k, k + its[i]):\\n seq += [i]\\n k += 1\\n\\n # Edges that link to other modules\\n c_node = np.random.choice(seq, size=c, replace=False)\\n for i in range(c):\\n seq.remove(c_node[i])\\n \\n # Connects the half-edges randomly among each other\\n np.random.shuffle(seq)\\n links = np.sort(np.reshape(seq, (int(len(seq)/2), 2)))\\n links = links.tolist()\\n \\n # Separates the unique and the multi/self links.\\n # The list links is left with multi and self links.\\n links_unique = []\\n k = 0\\n while k < len(links):\\n if links[k][0] != links[k][1] and links[k] not in links_unique:\\n links_unique.append(links.pop(k))\\n else:\\n k += 1\\n \\n # Rewires the multi/self links\\n for multi in links:\\n r1 = random.randint(0, len(links_unique)-1)\\n r2 = random.randint(0, 1)\\n r3 = random.randint(0, 1)\\n links_unique[r1][r2], multi[r3] = multi[r3], links_unique[r1][r2]\\n \\n network = gt.Graph(directed=False)\\n network.add_edge_list(links_unique)\\n network.add_edge_list(links)\\n\\n gt.stats.remove_parallel_edges(network)\\n gt.stats.remove_self_loops(network)\\n \\n return network, c_node\",\n \"def possible(self):\\n return [tuple(path) for path in nx.all_shortest_paths(self._gpm.Graph, source=self.source, target=self.target)]\",\n \"def _ism_get_mirror_sources(source, receiver, walls, order_threshold, mirrors_threshold):\\n logger.info(\\\"_ism_get_mirror_sources: Determining mirror sources.\\\")\\n model = ism.Model(walls=walls, source=source, receiver=receiver, max_order=order_threshold)\\n mirrors = model.determine(strongest=mirrors_threshold)\\n yield from mirrors\",\n \"def connecting_graph(self, solution_graph, weight='cost', ignore_sources=False):\\n debut = time.time()\\n self.logger.info('start connecting graph')\\n\\n # we need an undirected graph\\n undirected_solution_graph = solution_graph.to_undirected()\\n\\n if self.old_network_graph is not None and self.modify_old_network:\\n undirected_solution_graph = nx.compose(nx.MultiGraph(self.old_network_graph), undirected_solution_graph)\\n\\n # if already connected\\n if nx.is_connected(undirected_solution_graph) == True:\\n self.logger.info(\\\"the solution graph is already connected\\\")\\n return []\\n\\n # Computing the minimum sources in each component and all junction nodes in the solution graph\\n nodetype = nx.get_node_attributes(undirected_solution_graph, config.NODE_TYPE_KEY)\\n list_sources = [node for node in nodetype if nodetype[node] == config.SUPPLY_NODE_TYPE]\\n\\n # 1. Search of all connected subgraphs\\n if not ignore_sources:\\n reduced_list_sources = []\\n while len(list_sources) > 0:\\n source, is_isolated = list_sources.pop(0), True\\n for i in range(len(list_sources)):\\n is_isolated = is_isolated and not (nx.has_path(undirected_solution_graph, source, list_sources[i]))\\n if is_isolated:\\n reduced_list_sources.append(source)\\n else:\\n reduced_list_sources = [list(n)[0] for n in nx.connected_components(undirected_solution_graph)]\\n\\n # 2. Creation of all convex hulls for each source in reduced_list_sources\\n hulls = {}\\n for source in reduced_list_sources:\\n coord_compo = {}\\n nodes_connecting_source = nx.node_connected_component(undirected_solution_graph, source)\\n for node in nodes_connecting_source:\\n xy = tuple(self.optimization_graph.get_node_coordinates(node))\\n coord_compo[xy] = node\\n if len(coord_compo) > 2:\\n convexhull = ConvexHull(list(coord_compo.keys())).points\\n else:\\n convexhull = list(coord_compo.keys())\\n hulls[source] = [coord_compo[tuple(coord)] for coord in convexhull]\\n\\n # 3. Create list of possible list_edges_to_add\\n list_edges_to_add = {} # list of {(S1, S2):(length_of_SP, edges_to_add)}\\n\\n for S1, S2 in combinations(reduced_list_sources, 2):\\n\\n # change weight of edges\\n for i in range(len(hulls[S1])-1):\\n u,v = hulls[S1][i], hulls[S1][i+1]\\n self.optimization_graph.add_edge(u,v,key=-1,weight=0)\\n self.optimization_graph.add_edge(hulls[S1][-1],hulls[S1][0],key=-1,weight=0)\\n for i in range(len(hulls[S2])-1):\\n u,v = hulls[S2][i], hulls[S2][i+1]\\n self.optimization_graph.add_edge(u,v,key=-1,weight=0)\\n self.optimization_graph.add_edge(hulls[S2][-1],hulls[S2][0],key=-1,weight=0)\\n\\n # find the shortest path\\n source, target = hulls[S1][0], hulls[S2][0] # it's a choice to take 0, but no matter\\n try:\\n length, path = nx.single_source_dijkstra(self.optimization_graph, source, target=target, weight=weight)\\n except nx.NetworkXNoPath:\\n self.logger.info(\\\"Source \\\" + str(S1) + \\\" and source \\\" + str(S2) + \\\" can't be connected\\\")\\n return []\\n list_weights = nx.get_edge_attributes(self.optimization_graph, weight)\\n\\n # edges to add to connect S1 and S2\\n edges_to_add = []\\n for i in range(len(path) - 1):\\n u, v = path[i], path[i + 1]\\n # if the edge between (u,v) is not artificial, we add it\\n if list_weights.get((u, v, -1), None) != 0 and list_weights.get((u, v, 0), None) is not None:\\n edges_to_add.append((u, v, 0))\\n if list_weights.get((v, u, -1), None) != 0 and list_weights.get((v, u, 0), None) is not None:\\n edges_to_add.append((v, u, 0))\\n list_edges_to_add[(S1, S2)] = (length, edges_to_add)\\n\\n # change weight of edges\\n for i in range(len(hulls[S1])-1):\\n u,v = hulls[S1][i], hulls[S1][i+1]\\n self.optimization_graph.remove_edge(u,v,key=-1)\\n self.optimization_graph.remove_edge(hulls[S1][-1],hulls[S1][0],key=-1)\\n for i in range(len(hulls[S2])-1):\\n u,v = hulls[S2][i], hulls[S2][i+1]\\n self.optimization_graph.remove_edge(u,v,key=-1)\\n self.optimization_graph.remove_edge(hulls[S2][-1],hulls[S2][0],key=-1)\\n\\n\\n # 4. choice of best edges to add (Kruskal)\\n G = nx.Graph()\\n for (S1, S2) in list_edges_to_add:\\n (length, _) = list_edges_to_add[(S1, S2)]\\n if not G.has_node(S1):\\n G.add_node(S1)\\n if not G.has_node(S2):\\n G.add_node(S2)\\n G.add_edge(S1, S2, weight=length)\\n\\n reduced_list_edges_to_add = set()\\n T = nx.minimum_spanning_tree(G)\\n for u, v in T.edges:\\n if (u, v) in list_edges_to_add:\\n reduced_list_edges_to_add = reduced_list_edges_to_add.union(set(list_edges_to_add[(u, v)][1]))\\n if (v, u) in list_edges_to_add:\\n reduced_list_edges_to_add = reduced_list_edges_to_add.union(set(list_edges_to_add[(v, u)][1]))\\n\\n self.logger.info('end connecting graph in ' + str(time.time() - debut) + ' s')\\n return list(reduced_list_edges_to_add)\",\n \"def _measure(d, sources, target, niter=25, bound=None):\\n uniques = {}\\n for source in sources:\\n others = list(sources)\\n others.remove(source)\\n others = list(flatten(others))\\n uniques[source] = one_way_skar(d, source, target, others)\\n return uniques\",\n \"def find_unique_paths(self, source: str, target: str, number: int = 3) -> List[Tuple[List[str], float]]:\\n assert self.graph_handler\\n counter = 0\\n path_tuple_list = list()\\n # # # Initialise iterator over shortest simple paths if it is either not set or source/target do not match\\n if not self._use_old_iterator or \\\\\\n self._unique_iterator_memory is None or \\\\\\n self._unique_iterator_memory[0][0][0] != source or \\\\\\n self._unique_iterator_memory[0][0][-1] != target:\\n path_iterator = iter(nx.shortest_simple_paths(self.graph_handler.graph, source, target, weight=\\\"weight\\\"))\\n # # # Find first path and its cost\\n old_path = next(path_iterator)\\n old_path_cost = nx.path_weight(self.graph_handler.graph, old_path, weight=\\\"weight\\\")\\n else:\\n path_iterator = self._unique_iterator_memory[1]\\n old_path = self._unique_iterator_memory[0][0]\\n old_path_cost = self._unique_iterator_memory[0][1]\\n\\n while counter < number:\\n same_cost = True\\n tmp_path_list: List[List[str]] = list()\\n # # # Collect all paths with same cost\\n # TODO: Parameter for max tmp paths\\n n_max_collected_paths = 10\\n while same_cost and len(tmp_path_list) < n_max_collected_paths:\\n # # # Append old path to tmp_path list\\n tmp_path_list.append(old_path)\\n # # # Get next path and its cost\\n new_path = next(path_iterator, None)\\n # # # Break loop if no path is returned\\n if new_path is None:\\n break\\n new_path_cost = nx.path_weight(self.graph_handler.graph, new_path, weight=\\\"weight\\\")\\n # # # Check if new cost different to old cost\\n if abs(old_path_cost - new_path_cost) > 1e-12:\\n same_cost = False\\n # # # Overwrite old path with new path\\n old_path = new_path\\n\\n # # # Append path with most nodes to tuple list and its cost\\n path_tuple_list.append((max(tmp_path_list, key=lambda x: len(x)), # pylint: disable=unnecessary-lambda\\n old_path_cost))\\n # # # Break counter loop if no more paths to target are found\\n if new_path is None:\\n break\\n old_path_cost = new_path_cost\\n counter += 1\\n # # # Store iterator and path info (list of nodes and length)\\n if new_path is not None:\\n self._unique_iterator_memory = ((new_path, new_path_cost), path_iterator)\\n return path_tuple_list\",\n \"def calc_granger_shuffle(self):\\n if not hasattr(self, 'input_data'):\\n self.preprocess_and_check_stationarity()\\n temp_series = [np.stack([np.random.permutation(x)\\n for x in self.input_data.T]).T\\n for i in trange(self.n_shuffles)]\\n\\n outs_temp = parallelize(self.calc_granger, temp_series, n_jobs=30)\\n outs_temp = [x[0] for x in outs_temp]\\n self.shuffle_outs = np.array(outs_temp)\",\n \"def generate_pairs(self, all_walks):\\n logging.info(['edge_types before generate pairs', self.edge_types])\\n\\n pairs = []\\n skip_window = self.config['win_size'] // 2\\n for layer_id, e_type in enumerate(self.edge_types):\\n walks = all_walks[e_type]\\n for walk in tqdm.tqdm(walks):\\n for i in range(len(walk)):\\n for j in range(1, skip_window + 1):\\n if i - j >= 0 and walk[i] != walk[i - j]:\\n neg_nodes = self.graph[e_type].sample_nodes(\\n self.config['neg_num'])\\n pairs.append(\\n (walk[i], walk[i - j], *neg_nodes, layer_id))\\n if i + j < len(walk) and walk[i] != walk[i + j]:\\n neg_nodes = self.graph[e_type].sample_nodes(\\n self.config['neg_num'])\\n pairs.append(\\n (walk[i], walk[i + j], *neg_nodes, layer_id))\\n return pairs\",\n \"def __generate_connecticity_increasing_canidates(self,k=3):\\n result = set()\\n \\n if k < 3:\\n k = 3\\n \\n self.__logger.info(\\\"IMPROOVE_NETWORK: Try to seek {} nodes which are currently bad connected\\\".format(k))\\n candidates = heapq.nlargest(3*k, self.__generate_all_shortest_paths(), key=itemgetter(0))\\n\\n for _, path in candidates:\\n result.add(path[0])\\n result.add(path[-1])\\n\\n self.__logger.info(\\\"IMPROOVE_NETWORK: Found {} candidates which are currently bad connected\\\".format(len(result))) \\n if len(result) <= k:\\n return list(result)\\n self.__logger.info(\\\"IMPROOVE_NETWORK: Sample {} items from the candidates as was requested\\\".format(k))\\n tmp = list(result)\\n random.shuffle(tmp)\\n return tmp[0:k]\",\n \"def generate_simple_flows(tgen_names, num_bots, bot_msg_size, bot_msg_rate, num_comps, comp_msg_size, comp_msg_rate):\\n bot_tgen_ips = [TGEN_IP_PATTERN.format(TGEN_SUBNET_BASE + i) for i in range(num_bots)]\\n bot_tgen_ports = [TGEN_PORT_BASE + i for i in range(num_bots)]\\n\\n # competitor IPs and port numbers start after those assigned to the bots\\n comp_tgen_ips = [TGEN_IP_PATTERN.format(TGEN_SUBNET_BASE + i) for i in range(num_bots, num_bots+num_comps)]\\n comp_tgen_ports = [TGEN_PORT_BASE + i for i in range(num_bots, num_bots+num_comps)]\\n\\n # build up flows for bots. Each bot talks to every other bot.\\n bot_flows = {}\\n for i in range(num_bots):\\n bot_flows[i] = {\\\"flows\\\": [], \\\"tgen_name\\\": tgen_names[i]}\\n\\n # add a flow for each neighbor bot\\n for j in range(len(bot_tgen_ips)):\\n # don't add flows to self\\n if i != j:\\n # send from a unique source port based on the DESTINATION node.\\n # use a destination port based on the SOURCE node number\\n bot_flows[i][\\\"flows\\\"].append({\\\"src_port\\\": bot_tgen_ports[j],\\n \\\"dst_ip\\\": bot_tgen_ips[j],\\n \\\"dst_port\\\": bot_tgen_ports[i],\\n \\\"msg_rate\\\": bot_msg_rate,\\n \\\"msg_size\\\": bot_msg_size,\\n })\\n\\n # build up flows for competitor nodes. Each competitor node talks to every other competitor node.\\n comp_flows = {}\\n for i in range(num_comps):\\n comp_flows[i] = {\\\"flows\\\": [], \\\"tgen_name\\\": tgen_names[i+num_bots]}\\n\\n # add a flow for each neighbor bot\\n for j in range(len(comp_tgen_ips)):\\n # don't add flows to self\\n if i != j:\\n # send from a unique source port based on the DESTINATION node.\\n # use a destination port based on the SOURCE node number\\n comp_flows[i][\\\"flows\\\"].append({\\\"src_port\\\": comp_tgen_ports[j],\\n \\\"dst_ip\\\": comp_tgen_ips[j],\\n \\\"dst_port\\\": comp_tgen_ports[i],\\n \\\"msg_rate\\\": comp_msg_rate,\\n \\\"msg_size\\\": comp_msg_size,\\n })\\n\\n return bot_flows, comp_flows\",\n \"def _measure(d, sources, target, niter=25, bound=None):\\n uniques = {}\\n for source in sources:\\n others = list(sources)\\n others.remove(source)\\n others = list(flatten(others))\\n uniques[source] = one_way_skar(d, target, source, others)\\n return uniques\",\n \"def generate_parameters_random_walk():\\r\\n\\r\\n logging.info('Loading distances_nets from disk...')\\r\\n\\r\\n\\r\\n\\r\\n sum_weights = {}\\r\\n\\r\\n amount_edges = {}\\r\\n\\r\\n\\r\\n\\r\\n layer = 0\\r\\n\\r\\n while is_pickle('distances_nets_weights-layer-' + str(layer)):\\r\\n\\r\\n logging.info('Executing layer {}...'.format(layer))\\r\\n\\r\\n weights = restore_variable_from_disk('distances_nets_weights-layer-' + str(layer))\\r\\n\\r\\n\\r\\n\\r\\n for node, list_weights in weights.items():\\r\\n\\r\\n if layer not in sum_weights:\\r\\n\\r\\n sum_weights[layer] = 0\\r\\n\\r\\n if layer not in amount_edges:\\r\\n\\r\\n amount_edges[layer] = 0\\r\\n\\r\\n\\r\\n\\r\\n for w in list_weights:\\r\\n\\r\\n sum_weights[layer] += w\\r\\n\\r\\n amount_edges[layer] += 1\\r\\n\\r\\n\\r\\n\\r\\n logging.info('Layer {} executed.'.format(layer))\\r\\n\\r\\n layer += 1\\r\\n\\r\\n\\r\\n\\r\\n average_weight = {}\\r\\n\\r\\n for layer in sum_weights.keys():\\r\\n\\r\\n average_weight[layer] = sum_weights[layer] / amount_edges[layer]\\r\\n\\r\\n\\r\\n\\r\\n logging.info(\\\"Saving average_weights on disk...\\\")\\r\\n\\r\\n save_variable_on_disk(average_weight, 'average_weight')\\r\\n\\r\\n\\r\\n\\r\\n amount_neighbours = {}\\r\\n\\r\\n\\r\\n\\r\\n layer = 0\\r\\n\\r\\n while is_pickle('distances_nets_weights-layer-' + str(layer)):\\r\\n\\r\\n logging.info('Executing layer {}...'.format(layer))\\r\\n\\r\\n weights = restore_variable_from_disk('distances_nets_weights-layer-' + str(layer))\\r\\n\\r\\n\\r\\n\\r\\n amount_neighbours[layer] = {}\\r\\n\\r\\n\\r\\n\\r\\n for node, list_weights in weights.items():\\r\\n\\r\\n cont_neighbours = 0\\r\\n\\r\\n for w in list_weights:\\r\\n\\r\\n if w > average_weight[layer]:\\r\\n\\r\\n cont_neighbours += 1\\r\\n\\r\\n amount_neighbours[layer][node] = cont_neighbours\\r\\n\\r\\n\\r\\n\\r\\n logging.info('Layer {} executed.'.format(layer))\\r\\n\\r\\n layer += 1\\r\\n\\r\\n\\r\\n\\r\\n logging.info(\\\"Saving amount_neighbours on disk...\\\")\\r\\n\\r\\n save_variable_on_disk(amount_neighbours, 'amount_neighbours')\",\n \"def simulate_graph(seed, cluster_sizes, del_factor, ins_factor):\\n rand.seed(seed)\\n cluster_boundaries = np.cumsum(cluster_sizes)\\n print(\\\"#seed:\\\", seed)\\n print(\\\"#deletion factor:\\\", del_factor)\\n print(\\\"#insertion factor:\\\", ins_factor)\\n optimal_costs = np.array([0])\\n for c in range(0, len(cluster_sizes)-1):\\n n_c = cluster_sizes[c+1]\\n offset_c = cluster_boundaries[c]\\n edges_c = generate_edges(n_c, offset_c)\\n disturb_cluster(n_c, offset_c, edges_c, del_factor, optimal_costs)\\n additional_edges(cluster_boundaries, ins_factor, optimal_costs)\\n print(\\\"#optimal costs:\\\", optimal_costs)\",\n \"def generate_visiting_scheme(self):\\n\\n def all_indices_shuffled():\\n _res = list(range(self.dataset.num_examples))\\n self.rnd.shuffle(_res)\\n return _res\\n\\n # noinspection PyUnusedLocal\\n _tmp_ts = np.concatenate(\\n [all_indices_shuffled() for _ in range(self.epochs or 1)]\\n )\\n self.training_schedule = (\\n _tmp_ts\\n if self.training_schedule is None\\n else np.concatenate([self.training_schedule, _tmp_ts])\\n ) # do not discard previous schedule,\\n # this should allow backward passes of arbitrary length\\n\\n return self\",\n \"def choose_paths_without_simulation(FT, output_dir, iteration, pathset_paths_df, pathset_links_df, veh_trips_df):\\n simulation_iteration = 0\\n ######################################################################################################\\n FastTripsLogger.info(\\\" Step 1. Find out board/alight times for all pathset links from vehicle times\\\")\\n\\n # could do this just to chosen path links but let's do this to the whole pathset\\n pathset_links_df = Assignment.find_passenger_vehicle_times(pathset_links_df, veh_trips_df)\\n\\n # instead of flag_missed_transfers(), set these to pathfinding results\\n pathset_links_df[Assignment.SIM_COL_PAX_ALIGHT_DELAY_MIN] = 0\\n pathset_links_df[Assignment.SIM_COL_PAX_A_TIME ] = pathset_links_df[Passenger.PF_COL_PAX_A_TIME]\\n pathset_links_df[Assignment.SIM_COL_PAX_B_TIME ] = pathset_links_df[Passenger.PF_COL_PAX_B_TIME]\\n pathset_links_df[Assignment.SIM_COL_PAX_LINK_TIME ] = pathset_links_df[Passenger.PF_COL_LINK_TIME]\\n pathset_links_df[Assignment.SIM_COL_PAX_WAIT_TIME ] = pathset_links_df[Passenger.PF_COL_WAIT_TIME]\\n pathset_links_df[Assignment.SIM_COL_PAX_MISSED_XFER ] = 0\\n\\n ######################################################################################################\\n FastTripsLogger.info(\\\" Step 2. Calculate costs and probabilities for all pathset paths\\\")\\n (pathset_paths_df, pathset_links_df) = PathSet.calculate_cost(\\n iteration, simulation_iteration, Assignment.STOCH_DISPERSION,\\n pathset_paths_df, pathset_links_df, FT.passengers.trip_list_df,\\n FT.transfers.transfers_df, FT.tazs.walk_df, FT.tazs.drive_df, veh_trips_df, FT.stops)\\n\\n ######################################################################################################\\n FastTripsLogger.info(\\\" Step 3. Choose a path for each passenger from their pathset\\\")\\n\\n # Choose path for each passenger -- pathset_paths_df and pathset_links_df will now have\\n # SIM_COL_PAX_CHOSEN >=0 for chosen paths/path links\\n (num_passengers_arrived, num_chosen, pathset_paths_df, pathset_links_df) = Passenger.choose_paths(\\n True, # choose for everyone\\n iteration, simulation_iteration,\\n pathset_paths_df, pathset_links_df)\\n\\n # Write the pathsets\\n Passenger.write_paths(output_dir, iteration, simulation_iteration, pathset_paths_df, False, Assignment.OUTPUT_PATHSET_PER_SIM_ITER)\\n Passenger.write_paths(output_dir, iteration, simulation_iteration, pathset_links_df, True, Assignment.OUTPUT_PATHSET_PER_SIM_ITER)\\n\\n # write the final chosen paths for this iteration\\n chosen_links_df = Passenger.get_chosen_links(pathset_links_df)\\n chosen_links_df[\\\"iteration\\\"] = iteration\\n Util.write_dataframe(chosen_links_df, \\\"chosen_links_df\\\", os.path.join(output_dir, \\\"chosenpaths_links.csv\\\"), append=(iteration>1))\\n chosen_links_df.drop([\\\"iteration\\\"], axis=1, inplace=True)\\n\\n chosen_paths_df = Passenger.get_chosen_links(pathset_paths_df)\\n chosen_paths_df[\\\"iteration\\\"] = iteration\\n Util.write_dataframe(chosen_paths_df, \\\"chosen_paths_df\\\", os.path.join(output_dir, \\\"chosenpaths_paths.csv\\\"), append=(iteration>1))\\n chosen_paths_df.drop([\\\"iteration\\\"], axis=1, inplace=True)\\n\\n return (num_passengers_arrived, pathset_paths_df, pathset_links_df)\",\n \"def generate(\\n self,\\n num_nodes_src_set: int,\\n num_nodes_dst_set: int,\\n num_edges_src_dst: int,\\n num_edges_dst_src: int,\\n is_directed: bool,\\n return_node_ids: bool = False,\\n transform_graph: bool = True,\\n *args,\\n **kwargs,\\n ):\\n raise NotImplementedError()\",\n \"def k_shortest_paths(G, source, target, k=1, weight='weight'):\\n\\tif source == target:\\n\\t\\treturn ([0], [[source]]) \\n\\t \\n\\tlength, path = nx.single_source_dijkstra(G, source, target, weight=weight)\\n\\tif target not in length:\\n\\t\\traise nx.NetworkXNoPath(\\\"node %s not reachable from %s\\\" % (source, target))\\n\\t\\t\\n\\tlengths = [length[target]]\\n\\tpaths = [path[target]]\\n\\tc = count()\\t\\t\\n\\tB = []\\t\\t\\t\\t\\t\\t\\n\\tG_original = G.copy()\\t\\n\\t\\n\\tfor i in range(1, k):\\n\\t\\tfor j in range(len(paths[-1]) - 1):\\t\\t\\t\\n\\t\\t\\tspur_node = paths[-1][j]\\n\\t\\t\\troot_path = paths[-1][:j + 1]\\n\\t\\t\\t\\n\\t\\t\\tedges_removed = []\\n\\t\\t\\tfor c_path in paths:\\n\\t\\t\\t\\tif len(c_path) > j and root_path == c_path[:j + 1]:\\n\\t\\t\\t\\t\\tu = c_path[j]\\n\\t\\t\\t\\t\\tv = c_path[j + 1]\\n\\t\\t\\t\\t\\tif G.has_edge(u, v):\\n\\t\\t\\t\\t\\t\\tedge_attr = G.edge[u][v]\\n\\t\\t\\t\\t\\t\\tG.remove_edge(u, v)\\n\\t\\t\\t\\t\\t\\tedges_removed.append((u, v, edge_attr))\\n\\t\\t\\t\\n\\t\\t\\tfor n in range(len(root_path) - 1):\\n\\t\\t\\t\\tnode = root_path[n]\\n\\t\\t\\t\\t# out-edges\\n\\t\\t\\t\\tfor u, v, edge_attr in G.copy().edges_iter(node, data=True):\\n\\t\\t\\t\\t\\tG.remove_edge(u, v)\\n\\t\\t\\t\\t\\tedges_removed.append((u, v, edge_attr))\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif G.is_directed():\\n\\t\\t\\t\\t\\t# in-edges\\n\\t\\t\\t\\t\\tfor u, v, edge_attr in G.in_edges_iter(node, data=True):\\n\\t\\t\\t\\t\\t\\tG.remove_edge(u, v)\\n\\t\\t\\t\\t\\t\\tedges_removed.append((u, v, edge_attr))\\n\\t\\t\\t\\n\\t\\t\\tspur_path_length, spur_path = nx.single_source_dijkstra(G, spur_node, target, weight=weight)\\t\\t\\t\\n\\t\\t\\tif target in spur_path and spur_path[target]:\\n\\t\\t\\t\\ttotal_path = root_path[:-1] + spur_path[target]\\n\\t\\t\\t\\ttotal_path_length = get_path_length(G_original, root_path, weight) + spur_path_length[target]\\t\\t\\t\\t\\n\\t\\t\\t\\theappush(B, (total_path_length, next(c), total_path))\\n\\t\\t\\t\\t\\n\\t\\t\\tfor e in edges_removed:\\n\\t\\t\\t\\tu, v, edge_attr = e\\n\\t\\t\\t\\tG.add_edge(u, v, edge_attr)\\n\\t\\t\\t\\t\\t \\n\\t\\tif B:\\n\\t\\t\\t(l, _, p) = heappop(B)\\n\\t\\t\\tlengths.append(l)\\n\\t\\t\\tpaths.append(p)\\n\\t\\telse:\\n\\t\\t\\tbreak\\n\\t\\n\\treturn (lengths, paths)\",\n \"def k_shortest_paths(G, source, target, k=1, weight='weight'):\\n\\tif source == target:\\n\\t\\treturn ([0], [[source]]) \\n\\t \\n\\tlength, path = nx.single_source_dijkstra(G, source, target, weight=weight)\\n\\tif target not in length:\\n\\t\\traise nx.NetworkXNoPath(\\\"node %s not reachable from %s\\\" % (source, target))\\n\\t\\t\\n\\tlengths = [length[target]]\\n\\tpaths = [path[target]]\\n\\tc = count()\\t\\t\\n\\tB = []\\t\\t\\t\\t\\t\\t\\n\\tG_original = G.copy()\\t\\n\\t\\n\\tfor i in range(1, k):\\n\\t\\tfor j in range(len(paths[-1]) - 1):\\t\\t\\t\\n\\t\\t\\tspur_node = paths[-1][j]\\n\\t\\t\\troot_path = paths[-1][:j + 1]\\n\\t\\t\\t\\n\\t\\t\\tedges_removed = []\\n\\t\\t\\tfor c_path in paths:\\n\\t\\t\\t\\tif len(c_path) > j and root_path == c_path[:j + 1]:\\n\\t\\t\\t\\t\\tu = c_path[j]\\n\\t\\t\\t\\t\\tv = c_path[j + 1]\\n\\t\\t\\t\\t\\tif G.has_edge(u, v):\\n\\t\\t\\t\\t\\t\\tedge_attr = G.edge[u][v]\\n\\t\\t\\t\\t\\t\\tG.remove_edge(u, v)\\n\\t\\t\\t\\t\\t\\tedges_removed.append((u, v, edge_attr))\\n\\t\\t\\t\\n\\t\\t\\tfor n in range(len(root_path) - 1):\\n\\t\\t\\t\\tnode = root_path[n]\\n\\t\\t\\t\\t# out-edges\\n\\t\\t\\t\\tfor u, v, edge_attr in G.copy().edges_iter(node, data=True):\\n\\t\\t\\t\\t\\tG.remove_edge(u, v)\\n\\t\\t\\t\\t\\tedges_removed.append((u, v, edge_attr))\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif G.is_directed():\\n\\t\\t\\t\\t\\t# in-edges\\n\\t\\t\\t\\t\\tfor u, v, edge_attr in G.in_edges_iter(node, data=True):\\n\\t\\t\\t\\t\\t\\tG.remove_edge(u, v)\\n\\t\\t\\t\\t\\t\\tedges_removed.append((u, v, edge_attr))\\n\\t\\t\\t\\n\\t\\t\\tspur_path_length, spur_path = nx.single_source_dijkstra(G, spur_node, target, weight=weight)\\t\\t\\t\\n\\t\\t\\tif target in spur_path and spur_path[target]:\\n\\t\\t\\t\\ttotal_path = root_path[:-1] + spur_path[target]\\n\\t\\t\\t\\ttotal_path_length = get_path_length(G_original, root_path, weight) + spur_path_length[target]\\t\\t\\t\\t\\n\\t\\t\\t\\theappush(B, (total_path_length, next(c), total_path))\\n\\t\\t\\t\\t\\n\\t\\t\\tfor e in edges_removed:\\n\\t\\t\\t\\tu, v, edge_attr = e\\n\\t\\t\\t\\tG.add_edge(u, v, edge_attr)\\n\\t\\t\\t\\t\\t \\n\\t\\tif B:\\n\\t\\t\\t(l, _, p) = heappop(B)\\t\\t\\n\\t\\t\\tlengths.append(l)\\n\\t\\t\\tpaths.append(p)\\n\\t\\telse:\\n\\t\\t\\tbreak\\n\\t\\n\\treturn (lengths, paths)\",\n \"def _measure(d, sources, target, niter=25, bound=None):\\n uniques = {}\\n for source in sources:\\n others = list(sources)\\n others.remove(source)\\n others = list(flatten(others))\\n uniques[source] = two_way_skar(d, [source, target], others)\\n return uniques\",\n \"def greedy(self):\\n # for each node, find the incoming link with the highest score.\\n max_scores = {}\\n max_sources = {}\\n for source, target in self.iteredges():\\n score = self.get_score(source, target)\\n max_score = max_scores.get(target)\\n if max_score is None or score > max_score:\\n max_scores[target] = score\\n max_sources[target] = source\\n # then build a graph out of just these links.\\n succs = dict((n, []) for n in self)\\n for target, source in max_sources.items():\\n succs[source].append(target)\\n return Digraph(succs, self.get_score, self.get_label)\",\n \"def createTrialBatchesWithDynamics((taskRuleSet,nTasks,shuffle,batchNum)):\\n if batchNum%100==0:\\n print 'Running batch', batchNum\\n\\n nMiniblocks = nTasks\\n nTasks = nTasks # Corresponds to the number of miniblocks\\n n_trials_per_block = 3\\n shuffle=True\\n \\n stimuliSet = task.createSensoryInputs()\\n\\n networkIO_DataFrame = {}\\n networkIO_DataFrame['LogicRule'] = []\\n networkIO_DataFrame['SensoryRule'] = []\\n networkIO_DataFrame['MotorRule'] = []\\n networkIO_DataFrame['Color1'] = []\\n networkIO_DataFrame['Color2'] = []\\n networkIO_DataFrame['Orientation1'] = []\\n networkIO_DataFrame['Orientation2'] = []\\n networkIO_DataFrame['Pitch1'] = []\\n networkIO_DataFrame['Pitch2'] = []\\n networkIO_DataFrame['Constant1'] = []\\n networkIO_DataFrame['Constant2'] = []\\n networkIO_DataFrame['MotorResponse'] = []\\n\\n # Create 1d array to randomly sample indices from\\n stimIndices = np.arange(len(stimuliSet))\\n taskIndices = np.arange(len(taskRuleSet))\\n \\n randomTaskIndices = np.random.choice(taskIndices,nTasks,replace=False)\\n taskRuleSet2 = taskRuleSet.iloc[randomTaskIndices].copy(deep=True)\\n taskRuleSet2 = taskRuleSet2.reset_index(drop=True)\\n taskRuleSet = taskRuleSet2.copy(deep=True)\\n\\n# networkInputCode = []\\n# networkOutputCode = []\\n# for taskrule in taskRuleSet.index:\\n# \\n# randomStimuliIndices = np.random.choice(stimIndices,n_trials_per_block,replace=False)\\n# stimuliSet2 = stimuliSet.iloc[randomStimuliIndices].copy(deep=True)\\n# stimuliSet2 = stimuliSet2.reset_index(drop=True)\\n# \\n# for trial in stimuliSet2.index:\\n#\\n# networkInputCode.append(np.hstack((taskRuleSet.Code[taskrule], stimuliSet2.Code[trial])))\\n# tmpresp, tmpcode = task.solveInputs(taskRuleSet.iloc[taskrule], stimuliSet2.iloc[trial])\\n# networkOutputCode.append(tmpcode)\\n\\n \\n\\n ####\\n # Construct trial dynamics\\n rule_ind = np.arange(12) # rules are the first 12 indices of input vector\\n stim_ind = np.arange(12,28) # stimuli are the last 16 indices of input vector\\n input_size = len(rule_ind) + len(stim_ind)\\n n_tp_total = 36 # total length of miniblock -- cpro task details\\n input_matrix = np.zeros((input_size,n_tp_total,nMiniblocks))\\n output_matrix = np.zeros((4,n_tp_total,nMiniblocks))\\n trial = 0\\n for block in range(nMiniblocks):\\n # Define trial dynamics\\n n_tp_encoding = 5\\n n_tp_encodingdelay = np.random.randint(2,9) # encoding delay is jittered from 2 - 8 trs\\n n_tp_trial = 3\\n n_tp_probedelay = 2\\n n_tp_trial_end = n_tp_total - n_tp_encoding - n_tp_encodingdelay - n_tp_trial*3 - n_tp_probedelay*2 # full miniblock is 36 trs\\n\\n\\n rand_stim_ind = np.random.choice(stimIndices,n_trials_per_block,replace=False)\\n stimuliSet2 = stimuliSet.iloc[rand_stim_ind].copy(deep=True)\\n stimuliSet2 = stimuliSet2.reset_index(drop=True)\\n \\n # Create trial array\\n networkInputCode2 = []\\n networkOutputCode2 = []\\n tp = 0\\n # Encoding\\n for i in range(n_tp_encoding):\\n input_matrix[rule_ind,tp,block] = taskRuleSet.Code[block] \\n tp += 1\\n\\n # Encoding delay\\n tp += n_tp_encodingdelay\\n\\n # Trials\\n for trial in range(n_trials_per_block):\\n # First solve trial\\n tmpresp, out_code = task.solveInputs(taskRuleSet.iloc[block], stimuliSet2.iloc[trial])\\n\\n # probe\\n for i in range(n_tp_trial):\\n input_matrix[stim_ind,tp,block] = stimuliSet2.Code[trial]\\n # Commented out - response period will be limited to ITI following stimulus\\n #output_matrix[:,tp,block] = out_code\\n tp += 1\\n\\n # probe delay\\n for i in range(n_tp_probedelay):\\n output_matrix[:,tp,block] = out_code\\n tp += 1\\n \\n if shuffle:\\n ind = np.arange(input_matrix.shape[2],dtype=int)\\n np.random.shuffle(ind)\\n input_matrix = input_matrix[:,:,ind]\\n output_matrix = output_matrix[:,:,ind]\\n \\n return input_matrix, output_matrix\",\n \"def get_all_pairs(G):\\n # list all (start,dest) pairs between which the route must be computed\\n pairs_list = [(start, dest) for dest in G.nodes for start in G.nodes]\\n\\n # shuffle all elements in-place\\n random.shuffle(pairs_list)\\n\\n # generate a set from the list\\n pairs_set = set(pairs_list)\\n\\n return pairs_list, pairs_set\",\n \"def shiftFlows(self, targetFlows, stepSize):\\n for l in self.link:\\n current = self.link[l].flow\\n target = targetFlows[l]\\n new = current *(1 - stepSize)+target*stepSize\\n self.link[l].flow = new\\n self.link[l].updateCost()\",\n \"def step(nodes, outputs, edges):\\n flowed = []\\n for node_name in nodes.copy():\\n if node_name in flowed:\\n continue\\n if len(nodes[node_name]) == 2:\\n if node_name in flowed:\\n continue\\n node = [int(value) for value in nodes[node_name]]\\n low_value, high_value = min(node), max(node)\\n low_flow, high_flow = edges[node_name] \\n low_dictionary, low_node_name = low_flow\\n high_dictionary, high_node_name = high_flow\\n low_node = low_dictionary.get(low_node_name, tuple())\\n high_node = high_dictionary.get(high_node_name, tuple())\\n low_dictionary[low_node_name] = low_node + (str(low_value),)\\n high_dictionary[high_node_name] = high_node + (str(high_value),)\\n nodes[node_name] = tuple()\\n if low_dictionary is nodes:\\n flowed.append(low_node_name)\\n if high_dictionary is nodes:\\n flowed.append(high_node_name)\\n return nodes, outputs, edges\",\n \"def shuffle(self):\\n self.edges = np.random.permutation(self.edges)\\n self.batch_num = 0\",\n \"def flowers(self):\\n return self._flowers\",\n \"def sources(self):\\n return [x for x in self if self.in_degree(x)==0]\",\n \"def optimal_route(graph,homes,source):\\n number_of_homes = len(homes)\\n all_pairs_distances = dict(nx.shortest_path_length(graph, weight = 'weight'))\\n all_pairs_shortest_paths = dict(nx.shortest_path(graph, weight = 'weight'))\\n homes_subgraph = tsp_routines.complete_shortest_path_subgraph_efficient(graph,homes,all_pairs_distances)\\n num_clusters_to_clustering = clustering_routines.all_k_clusters(homes_subgraph,number_of_homes)\\n \\n cluster_list = range(1,number_of_homes+1)\\n optimal_cost = np.Inf\\n optimal_dropoffs = dict()\\n optimal_route = []\\n optimal_num_clusters = 0\\n\\n\\n for num_clusters in cluster_list:\\n home_clusters = num_clusters_to_clustering[num_clusters]\\n cost, dropoffs, route = solver(graph,homes,source,home_clusters,all_pairs_distances,all_pairs_shortest_paths)\\n if cost < optimal_cost:\\n optimal_cost = cost\\n optimal_route = route \\n optimal_dropoffs = dropoffs\\n optimal_num_clusters = num_clusters\\n\\n return optimal_cost, optimal_dropoffs, optimal_route, optimal_num_clusters\",\n \"def dfs_edges_generator(graph, source, reverse=...):\\n ...\",\n \"def traverse_graph(F, f, s, t, u, sr):\\n def get_paths_for_flow(F, s, f):\\n \\\"\\\"\\\"\\n RETURNS\\n A set of outgoing links and corresponding splitting ratios for flow f\\n at node s\\n \\\"\\\"\\\"\\n links = [((u, v), split_ratio) \\n for (flow_id, u, v), split_ratio in F.items() \\n if flow_id == f and u == s and split_ratio > 0.001]\\n return links\\n \\n if u == t:\\n return [([t], sr)]\\n\\n outgoing_links = get_paths_for_flow(F, u, f)\\n paths_to_t = []\\n\\n for ((current_node, next_hop), split_ratio) in outgoing_links:\\n paths_from_u_to_t = traverse_graph(F, f, s, t, next_hop, split_ratio) \\n paths_to_t.extend(paths_from_u_to_t)\\n\\n paths_to_t_with_u = []\\n for path in paths_to_t:\\n nodes, sr = path\\n new_path = [u] + nodes\\n paths_to_t_with_u.append((new_path, sr))\\n\\n return paths_to_t_with_u\",\n \"def gen_task_sets_simplegen(nsets):\\n start = time()\\n eval_task_sets = []\\n for util in utils:\\n task_sets = []\\n for i in range(nsets):\\n ts = synth.simplegen(i, util, implicit_deadlines=True)\\n synth.synth_c_pmf(ts, distribution_cls=lib.ExpExceedDist)\\n synth.set_fixed_priorities(ts)\\n task_sets.append(ts)\\n eval_task_sets.append(task_sets)\\n stop = time()\\n print('Task Set Generation SimpleGen: %.3fs' % (stop - start))\\n pickle.dump(eval_task_sets, open(task_sets_path + 'task_sets_simplegen', 'wb'))\",\n \"def _ppsc_gossip(self):\\n for i in range(self.s):\\n for edges in self.all_edges:\\n # for each connected component\\n selected_edge = random.choice(edges)\\n self._ppsc_gossip_edge(selected_edge)\",\n \"def _get_allow_all_flows() -> List[FlowDescription]:\\n return [\\n # Set flow match for all packets\\n # Don't set the app_name field\\n FlowDescription( # uplink flow\\n match=FlowMatch(\\n direction=FlowMatch.Direction.Value(\\\"UPLINK\\\"),\\n ),\\n action=FlowDescription.Action.Value(\\\"PERMIT\\\"),\\n ),\\n FlowDescription( # downlink flow\\n match=FlowMatch(\\n direction=FlowMatch.Direction.Value(\\\"DOWNLINK\\\"),\\n ),\\n action=FlowDescription.Action.Value(\\\"PERMIT\\\"),\\n ),\\n ]\",\n \"def generate_graph(self):\\n temp_graph = [[] for i in xrange(Parameters.num_peers)]\\n unconnected = set([i for i in xrange(Parameters.num_peers)])\\n while len(unconnected) > 1:\\n node1 = random.sample(unconnected, 1)[0]\\n unconnected.remove(node1)\\n node2 = random.sample(unconnected, 1)[0]\\n temp_graph[node2].append(self.nodes[node1])\\n temp_graph[node1].append(self.nodes[node2])\\n unconnected = set([i for i in xrange(Parameters.num_peers)])\\n i = 0\\n for i in xrange(Parameters.num_peers*Parameters.num_neighbours/2-Parameters.num_peers):\\n a = random.sample(unconnected, 1)[0]\\n b = random.sample(unconnected, 1)[0]\\n while b == a:\\n b = random.sample(unconnected, 1)[0]\\n temp_graph[a].append(self.nodes[b])\\n temp_graph[b].append(self.nodes[a])\\n graph = {}\\n for i in xrange(len(self.nodes)):\\n graph[\\\"P_\\\" + str(i)] = list(set(temp_graph[i]))\\n return graph\",\n \"def _graph_fn_sample_stochastic(distribution):\\n return distribution.sample()\",\n \"def sample_paths(S0, N, u, d, q, M):\\n value = S0 * np.ones((M, 1)) # M sample paths at once\\n paths = np.zeros((M, N + 1))\\n paths[:, 0] = value[:, 0]\\n for i in np.arange(1, N + 1, 1): # time steps\\n random_values = bernoulli.rvs(size=(M, 1), p=q)\\n up_moves = random_values * u\\n down_moves = -1 * (random_values - 1) * d\\n value = np.multiply(value, up_moves + down_moves)\\n paths[:, i] = value[:, 0]\\n return paths\",\n \"def Generate_edges(size, connectedness):\\r\\n\\r\\n assert connectedness <= 1\\r\\n random.seed(10)\\r\\n for i in range(size):\\r\\n for j in range(i + 1, size):\\r\\n if random.randrange(0, 100) <= connectedness * 100:\\r\\n yield f'{i} {j}'\",\n \"def run(graph: Graph) -> List[Edge]:\\n edges = sorted(WeightedEdge(edge) for edge in graph.get_edges())\\n partitions = UnionFind()\\n mst = []\\n\\n for edge in edges:\\n added = partitions.union(edge.source, edge.target)\\n if added:\\n mst.append(edge._edge)\\n\\n if len(mst) == graph.get_number_of_nodes() - 1:\\n break\\n\\n return mst\",\n \"def make_heuristic_list():\\n heuristics = [lambda n_p: (-n_p[0], (n_p[1] >> 16), (n_p[1] & 0xffff)),\\n lambda n_p: (-n_p[0], (n_p[1] & 0xffff), (n_p[1] >> 16)),\\n lambda n_p: ((n_p[1] >> 16), -n_p[0], (n_p[1] & 0xffff)),\\n lambda n_p: ((n_p[1] & 0xffff), -n_p[0], (n_p[1] >> 16)),\\n lambda n_p: ((n_p[1] >> 16), (n_p[1] & 0xffff)),\\n lambda n_p: ((n_p[1] & 0xffff), (n_p[1] >> 16))]\\n samples = 50\\n for ij in range(samples):\\n for ratio in range(5):\\n split = ij / float(samples - 1)\\n heuristics.append(make_angle_heuristic(split, 1.0 - split, ratio))\\n return heuristics\",\n \"def ssf(n, N_max = 6, E_max = 4, time_total = 100 ):\\n\\n G = nx.DiGraph()\\n G.add_edge( 0, 1, time_stamp = 1)\\n\\n # List of existing nodes, with nodes repeated once for each adjacent edge\\n repeated_nodes = [0, 1]\\n\\n # compute discrete bins for nodes \\n DistNodes = _get_distribution( N_max, 0 )\\n # compute discrete bins for edges\\n DistLinks = _get_distribution( E_max, 1 )\\n \\n # Start adding the other n - 2 nodes.\\n N_current = time_current = 2\\n while N_current < n and time_current < time_total + 1:\\n # preferential attachment\\n N_current = _preferential_attachment( DistNodes, DistLinks, N_current,\\n time_total, time_current, n, repeated_nodes, G )\\n time_current += 1\\n \\n# print(time_current, N_current)\\n return G\",\n \"def naiveGlobalRouting(self):\\n for e_list in self.s2e.values():\\n for e in e_list:\\n slot_path = []\\n src_slot = self.v2s[e.src]\\n dst_slot = self.v2s[e.dst]\\n slot_path.append(src_slot)\\n\\n curr = src_slot\\n len_x = src_slot.getLenX()\\n len_y = src_slot.getLenY()\\n\\n # first go in X direction\\n x_diff = curr.getPositionX() - dst_slot.getPositionX()\\n if x_diff:\\n dir = 'LEFT' if x_diff > 0 else 'RIGHT'\\n for i in range(int(abs(x_diff/len_x))):\\n curr = self.slot_manager.createSlotForRouting(curr.getNeighborSlotName(dir))\\n slot_path.append(curr)\\n\\n y_diff = curr.getPositionY() - dst_slot.getPositionY()\\n if y_diff:\\n dir = 'DOWN' if y_diff > 0 else 'UP'\\n for i in range(int(abs(y_diff/len_y))):\\n curr = self.slot_manager.createSlotForRouting(curr.getNeighborSlotName(dir))\\n slot_path.append(curr)\\n \\n assert curr == dst_slot\\n \\n slot_path = slot_path[1:-1] # exclude the src and the dst\\n logging.info(f'{e.name}: {self.v2s[e.src].getName()} -> {self.v2s[e.dst].getName()} : ' + ' '.join(s.getName() for s in slot_path))\\n self.e_name2path[e.name] = slot_path\",\n \"def sample_paths(S0, N, u, d, q, M):\\n value = S0*np.ones((M,1)) # M sample paths at once\\n paths = np.zeros((M, N+1))\\n paths[:,0] = value[:,0]\\n for i in np.arange(1, N+1,1): # time steps\\n random_values = bernoulli.rvs(size=(M,1),p=q)\\n up_moves = random_values*u\\n down_moves = -1*(random_values-1)*d \\n value = np.multiply(value,up_moves+down_moves)\\n paths[:,i] = value[:,0]\\n return paths\",\n \"def random_coaching_graph(num_classes, min_size, max_size, existing_rate):\\n\\n n = 0\\n coaching_graph = graph.Graph(directed=True)\\n for i in range(num_classes):\\n n += 1\\n class_size = random.randint(min_size, max_size)\\n coach = infect.User(str(n))\\n existing_users = coaching_graph.nodes()\\n num_existing = len(existing_users)\\n coaching_graph.add_node(coach)\\n for j in range(class_size):\\n if random.uniform(0,1) > existing_rate or num_existing < 100:\\n n += 1\\n user = infect.User(str(n))\\n else:\\n user = random.choice(existing_users)\\n\\n coaching_graph.add_edge(coach, user)\\n\\n\\n return coaching_graph\",\n \"def find_all_cycles(s,graph):\\n\\n grph = u.edge_to_list_dict(graph)\\n node_cnt = len(grph)\\n k = z.Int(\\\"k\\\")\\n syms = [z.Int('node%s'%i) for i in range(node_cnt)]\\n\\n # s.add(syms[0] == 0) # start node is a 0\\n s.add(k < node_cnt)\\n s.add(k > 1)\\n\\n o = z.Optimize()\\n\\n # for source, sinks in sgraph.s_adj_list():\\n for i in range(node_cnt):\\n s.add(syms[i] >= 0)\\n s.add(syms[i] <= k)\\n s.add(z.Or([syms[j] == ((syms[i] + 1) % k) for j in grph[i]]) == (syms[i] == 0))\\n\\n\\n r = []\\n m = []\\n\\n # o.minimize(z.Sum([syms[i] for i in range(node_cnt)]))\\n s.add(z.Product([syms[i] for i in range(node_cnt)]) == 0)\\n done = False\\n while not done:\\n if s.check() == z.sat:\\n m = s.model()\\n r.append(m)\\n s.add(k != m[k])\\n else:\\n done = True\\n\\n return r\",\n \"def fit(\\n self,\\n graph: List[Tuple[int, int]],\\n src_set: Set[int],\\n dst_set: Set[int],\\n is_directed: bool,\\n transform_graph: bool,\\n *args,\\n **kwargs,\\n ):\\n raise NotImplementedError()\",\n \"def search_shortest_paths(\\n self,\\n src_nodes: list[TN],\\n dst_node: TN,\\n operation_src: str,\\n operation_dest: str,\\n domain: str,\\n limit_dest_schemes: list[str],\\n *,\\n session: \\\"Session\\\",\\n ) -> dict[TN, list[dict[str, Any]]]:\\n\\n for rse in itertools.chain(src_nodes, [dst_node], self._multihop_nodes):\\n rse.ensure_loaded(load_attributes=True, load_info=True, session=session)\\n self.ensure_edges_loaded(session=session)\\n\\n if self._multihop_nodes:\\n # Filter out island source RSEs\\n nodes_to_find = {node for node in src_nodes if node.out_edges}\\n else:\\n nodes_to_find = set(src_nodes)\\n\\n class _NodeStateProvider:\\n _hop_penalty = self._hop_penalty\\n\\n def __init__(self, node: TN):\\n self.enabled: bool = True\\n self.cost: _Number = 0\\n if node != dst_node:\\n try:\\n self.cost = int(node.attributes.get('hop_penalty', self._hop_penalty))\\n except ValueError:\\n self.cost = self._hop_penalty\\n\\n scheme_missmatch_found = {}\\n\\n class _EdgeStateProvider:\\n def __init__(self, edge: TE):\\n self.edge = edge\\n self.chosen_scheme = {}\\n\\n @property\\n def cost(self) -> _Number:\\n return self.edge.cost\\n\\n @property\\n def enabled(self) -> bool:\\n try:\\n matching_scheme = rsemgr.find_matching_scheme(\\n rse_settings_src=self.edge.src_node.info,\\n rse_settings_dest=self.edge.dst_node.info,\\n operation_src=operation_src,\\n operation_dest=operation_dest,\\n domain=domain,\\n scheme=limit_dest_schemes if self.edge.dst_node == dst_node and limit_dest_schemes else None,\\n )\\n self.chosen_scheme = {\\n 'source_scheme': matching_scheme[1],\\n 'dest_scheme': matching_scheme[0],\\n 'source_scheme_priority': matching_scheme[3],\\n 'dest_scheme_priority': matching_scheme[2],\\n }\\n return True\\n except RSEProtocolNotSupported:\\n scheme_missmatch_found[self.edge.src_node] = True\\n return False\\n\\n paths = {dst_node: []}\\n for node, distance, _, edge_to_next_hop, edge_state in self.dijkstra_spf(dst_node=dst_node,\\n nodes_to_find=nodes_to_find,\\n node_state_provider=_NodeStateProvider,\\n edge_state_provider=_EdgeStateProvider):\\n nh_node = edge_to_next_hop.dst_node\\n edge_state = cast(_EdgeStateProvider, edge_state)\\n hop = {\\n 'source_rse': node,\\n 'dest_rse': nh_node,\\n 'hop_distance': edge_state.cost,\\n 'cumulated_distance': distance,\\n **edge_state.chosen_scheme,\\n }\\n paths[node] = [hop] + paths[nh_node]\\n\\n nodes_to_find.discard(node)\\n if not nodes_to_find:\\n # We found the shortest paths to all desired nodes\\n break\\n\\n result = {}\\n for node in src_nodes:\\n path = paths.get(node)\\n if path is not None:\\n result[node] = path\\n elif scheme_missmatch_found.get(node):\\n result[node] = []\\n return result\",\n \"def k_shortest_paths(\\n self,\\n G,\\n source,\\n target,\\n k=1,\\n weight='weight',\\n ):\\n\\n if source == target:\\n return ([0], [[source]])\\n\\n (length, path) = nx.single_source_dijkstra(G, source, target,\\n weight=weight)\\n if target not in length:\\n raise nx.NetworkXNoPath('node %s not reachable from %s' % (source,\\n target))\\n\\n lengths = [length[target]]\\n paths = [path[target]]\\n c = count()\\n B = []\\n\\n # Is deep copy really required?\\n # Fails due to embedded Ctype objects which can not be pickled\\n # # G_original = G.copy()\\n # Swapping with shallow copy...will it work?\\n\\n G_original = G\\n if nx.is_directed(G_original):\\n G = nx.DiGraph(G_original)\\n else:\\n G = nx.Graph(G_original)\\n\\n ######################################\\n #TODO: wrap this up somehow\\n print ''\\n print term.move_up + term.move_up\\n ######################################\\n print 'getting K:{} paths...'.format(k),\\n for i in range(1, k):\\n with term.location():\\n print i\\n for j in range(len(paths[-1]) - 1):\\n spur_node = paths[-1][j]\\n root_path = (paths[-1])[:j + 1]\\n\\n edges_removed = []\\n for c_path in paths:\\n if len(c_path) > j and root_path == c_path[:j + 1]:\\n u = c_path[j]\\n v = c_path[j + 1]\\n if G.has_edge(u, v):\\n edge_attr = G.edge[u][v]\\n G.remove_edge(u, v)\\n edges_removed.append((u, v, edge_attr))\\n\\n for n in range(len(root_path) - 1):\\n node = root_path[n]\\n\\n # out-edges\\n\\n for (u, v, edge_attr) in G.edges_iter(node, data=True):\\n\\n # print 'lala1: {} -> {}'.format(u,v)\\n\\n G.remove_edge(u, v)\\n edges_removed.append((u, v, edge_attr))\\n\\n if G.is_directed():\\n\\n # in-edges\\n\\n for (u, v, edge_attr) in G.in_edges_iter(node,\\n data=True):\\n\\n # print 'lala2: {} -> {}'.format(u,v)\\n\\n G.remove_edge(u, v)\\n edges_removed.append((u, v, edge_attr))\\n\\n (spur_path_length, spur_path) = nx.single_source_dijkstra(G,\\n spur_node, target, weight=weight)\\n if target in spur_path and spur_path[target]:\\n total_path = root_path[:-1] + spur_path[target]\\n total_path_length = self.get_path_length(G_original,\\n root_path, weight) + spur_path_length[target]\\n heappush(B, (total_path_length, next(c), total_path))\\n\\n for e in edges_removed:\\n (u, v, edge_attr) = e\\n G.add_edge(u, v, edge_attr)\\n\\n if B:\\n (l, _, p) = heappop(B)\\n lengths.append(l)\\n paths.append(p)\\n else:\\n break\\n\\n return (lengths, paths)\",\n \"def er_random_graph_generator(n, p, ng, seed, w_base, w_top):\\n\\n f_er_graph_list = []\\n for i in range(0, ng):\\n f_g = nx.erdos_renyi_graph(n, p, seed + i, directed=False)\\n for (u, v, w) in f_g.edges(data=True):\\n w['weight'] = random.randint(w_base, w_top)\\n f_er_graph_list.append(f_g)\\n return f_er_graph_list\",\n \"def generator(self, random, args):\\r\\n locations = [i for i in range(len(self.weights))]\\r\\n random.shuffle(locations)\\r\\n return locations\",\n \"def shuffle(self):\\n sampling_index = np.random.randint(0, self.total_negative_samples, self.neg_paths_per_epoch)\\n self.neg_paths_sampled = np.reshape(self.neg_paths[:, sampling_index , :], (-1, self.max_length))\\n self.neg_paths_words_sampled = np.reshape(self.neg_paths_words[:, sampling_index, :], (-1, self.max_length))\\n if self.schema != 'default':\\n self.neg_paths_rel1_sampled = np.reshape(self.neg_paths_rel1[:, sampling_index, :],(-1, self.max_length))\\n self.neg_paths_rel2_sampled = np.reshape(self.neg_paths_rel2[:, sampling_index, :],(-1, self.max_length))\\n self.neg_paths_rel3_sampled = np.reshape(self.neg_paths_rel3[:, sampling_index, :],(-1, self.max_length))\\n self.neg_paths_rel4_sampled = np.reshape(self.neg_paths_rel4[:, sampling_index, :],(-1, self.max_length))\\n\\n self.questions_shuffled, self.questions_dep_shuffled, self.questions_dep_mask_shuffled,\\\\\\n self.pos_paths_shuffled, \\\\\\n self.pos_paths_rel1_shuffled,self.pos_paths_rel2_shuffled, self.pos_paths_rel3_shuffled, self.pos_paths_rel4_shuffled, \\\\\\n self.neg_paths_shuffled, \\\\\\n self.neg_paths_rel1_shuffled, self.neg_paths_rel2_shuffled,self.neg_paths_rel3_shuffled,self.neg_paths_rel4_shuffled,\\\\\\n self.pos_paths_words_shuffled, self.neg_paths_words_shuffled = \\\\\\n shuffle(self.questions, self.questions_dep, self.questions_dep_mask,\\n self.pos_paths,\\n self.pos_paths_rel1, self.pos_paths_rel2,self.pos_paths_rel3,self.pos_paths_rel4,\\n self.neg_paths_sampled,\\n self.neg_paths_rel1_sampled, self.neg_paths_rel2_sampled, self.neg_paths_rel3_sampled, self.neg_paths_rel4_sampled,\\n self.pos_paths_words, self.neg_paths_words_sampled)\\n else:\\n self.questions_shuffled, self.questions_dep_shuffled, self.questions_dep_mask_shuffled,\\\\\\n self.pos_paths_shuffled, self.neg_paths_shuffled,self.pos_paths_words_shuffled, self.neg_paths_words_shuffled = \\\\\\n shuffle(self.questions, self.questions_dep, self.questions_dep_mask,\\n self.pos_paths, self.neg_paths_sampled,self.pos_paths_words,self.neg_paths_words_sampled)\",\n \"def _get_paths(G, nodes, edges, target, weight, available_dist, cache={}):\\n\\n G_succ = G.succ if G.is_directed() else G.adj\\n\\n output = []\\n visited = set(nodes)\\n path_info = []\\n source = nodes[-1]\\n get_weight = _create_weight_func(G, weight)\\n\\n for neighbor, neighbor_edge in G_succ[source].items():\\n\\n if neighbor in visited:\\n continue\\n\\n new_available_dist = available_dist - get_weight(source, neighbor)\\n\\n if new_available_dist < 0:\\n continue\\n\\n # shortest path key for cache\\n sp_key = (source, neighbor, target)\\n\\n if sp_key not in cache:\\n sp = dijkstra(G, neighbor, target, 'length', set([source]), \\n new_available_dist)\\n\\n cache[sp_key] = INF if not sp else sp[1]\\n\\n if new_available_dist < cache[sp_key]:\\n continue\\n\\n path_info.append((neighbor, neighbor_edge, new_available_dist))\\n\\n\\n for (neighbor, neighbor_edge, new_available_dist) in path_info:\\n new_path = nodes + [neighbor]\\n new_edges = edges + [neighbor_edge]\\n\\n if neighbor == target:\\n output.append((new_path, new_edges))\\n else:\\n output.extend(_get_paths(G, new_path, new_edges, target, \\n weight, new_available_dist, cache))\\n\\n return output\",\n \"def get_all_sghop_info (nffg, return_paths=False):\\n sg_map = {}\\n for i in nffg.infras:\\n for p in i.ports:\\n for fr in p.flowrules:\\n # if fr.external:\\n # continue\\n if fr.id not in sg_map:\\n # The path is unordered!!\\n path_of_shop = []\\n flowclass = NFFGToolBox._extract_flowclass(fr.match.split(\\\";\\\"))\\n sg_map[fr.id] = [None, None, flowclass, fr.bandwidth, fr.delay]\\n # We have to find the BEGINNING of this flowrule sequence.\\n inbound_link = NFFGToolBox._find_infra_link(nffg, p, outbound=False,\\n accept_dyn=True)\\n while inbound_link.type != 'DYNAMIC':\\n path_of_shop.append(inbound_link)\\n if inbound_link.src.node.type == 'SAP':\\n break\\n # The link is STATIC, and its src is not SAP so it is an Infra.\\n prev_fr, prev_p = \\\\\\n NFFGToolBox._get_flowrule_and_its_starting_port(\\n inbound_link.src.node, fr.id)\\n NFFGToolBox._check_flow_consistencity(sg_map, prev_fr)\\n inbound_link = NFFGToolBox._find_infra_link(nffg, prev_p,\\n outbound=False,\\n accept_dyn=True)\\n # 'inbound_link' is DYNAMIC here or it is STATIC and starts from\\n # a SAP,\\n # so the sequence starts here\\n sg_map[fr.id][0] = inbound_link.src\\n\\n # We have to find the ENDING of this flowrule sequence.\\n output_port = NFFGToolBox._get_output_port_of_flowrule(i, fr)\\n if output_port is None:\\n continue\\n outbound_link = NFFGToolBox._find_infra_link(nffg, output_port,\\n outbound=True,\\n accept_dyn=True)\\n while outbound_link.type != 'DYNAMIC':\\n path_of_shop.append(outbound_link)\\n if outbound_link.dst.node.type == 'SAP':\\n break\\n # The link is STATIC and its dst is not a SAP so it is an Infra.\\n next_fr, _ = NFFGToolBox._get_flowrule_and_its_starting_port(\\n outbound_link.dst.node, fr.id)\\n # '_' is 'outbound_link.dst'\\n next_output_port = NFFGToolBox._get_output_port_of_flowrule(\\n outbound_link.dst.node, next_fr)\\n NFFGToolBox._check_flow_consistencity(sg_map, next_fr)\\n outbound_link = NFFGToolBox._find_infra_link(nffg,\\n next_output_port,\\n outbound=True,\\n accept_dyn=True)\\n # the 'outbound_link' is DYNAMIC here or finishes in a SAP, so the\\n # flowrule sequence finished here.\\n sg_map[fr.id][1] = outbound_link.dst\\n\\n if return_paths:\\n sg_map[fr.id].append(path_of_shop)\\n\\n return sg_map\",\n \"def sinks(self):\\n s = [node for node in self.nodes() if node.isSink()]\\n s.sort(lambda x,y: cmp(x._id, y._id))\\n return s\",\n \"def prepare_k_fold(self, k_fold: int, shuffle: bool = True) \\\\\\n -> List[Tuple[ZLIMGS, ZLIMGS, ZLIMGS, ZLIMGS, ZLIMGS, ZLIMGS]]:\\n if self.setting == 'setting1':\\n warnings.warn(\\\"Setting 1 should not use train eval dataset! \\\"\\n \\\"Because its training set only contain normal samples!\\\")\\n\\n with open(self.json_path) as fp:\\n ids_json = json.load(fp)\\n ids_train_normal = ids_json['normal']['train']\\n ids_train_defect = ids_json['defect']['train']\\n\\n if shuffle:\\n self.rnd.shuffle(ids_train_normal)\\n self.rnd.shuffle(ids_train_defect)\\n ids_folds_normal = chunks(ids_train_normal, k_fold)\\n ids_folds_defect = chunks(ids_train_defect, k_fold)\\n\\n zlimgs_folds = []\\n for k in range(k_fold):\\n _ids_folds_normal = ids_folds_normal.copy()\\n _ids_folds_defect = ids_folds_defect.copy()\\n ids_k_dev_normal = _ids_folds_normal.pop(k)\\n ids_k_dev_defect = _ids_folds_defect.pop(k)\\n ids_k_train_normal = list(itertools.chain(*_ids_folds_normal))\\n ids_k_train_defect = list(itertools.chain(*_ids_folds_defect))\\n\\n # train\\n zlimgs_k_train_normal = self._create_zl_imgs_given_ids(ids=ids_k_train_normal,\\n subset=CONFIG[self.setting]['normal_train'],\\n ann_type=CONFIG[self.setting]['ann_train'])\\n zlimgs_k_train_defect = self._create_zl_imgs_given_ids(ids=ids_k_train_defect,\\n subset=CONFIG[self.setting]['defect_train'],\\n ann_type=CONFIG[self.setting]['ann_train'])\\n # train-eval\\n zlimgs_k_train_eval_normal = self._create_zl_imgs_given_ids(ids=ids_k_train_normal,\\n subset=CONFIG[self.setting]['normal_train'],\\n ann_type=CONFIG[self.setting]['ann_eval'])\\n zlimgs_k_train_eval_defect = self._create_zl_imgs_given_ids(ids=ids_k_train_defect,\\n subset=CONFIG[self.setting]['defect_train'],\\n ann_type=CONFIG[self.setting]['ann_eval'])\\n # dev\\n zlimgs_k_dev_normal = self._create_zl_imgs_given_ids(ids=ids_k_dev_normal, subset='dev',\\n ann_type=CONFIG[self.setting]['ann_eval'])\\n zlimgs_k_dev_defect = self._create_zl_imgs_given_ids(ids=ids_k_dev_defect, subset='dev',\\n ann_type=CONFIG[self.setting]['ann_eval'])\\n zlimgs_folds.append((zlimgs_k_train_normal, zlimgs_k_train_defect,\\n zlimgs_k_train_eval_normal, zlimgs_k_train_eval_defect,\\n zlimgs_k_dev_normal, zlimgs_k_dev_defect))\\n return zlimgs_folds\",\n \"def get_diffuse_sources(self, src_sel):\\n extended = self._select_and_freeze(self.extended_sources, src_sel)\\n for s in extended: # this seems redundant, but was necessary\\n s.model.free[:] = False if src_sel.frozen(s) else s.free[:]\\n sources.validate(s,self.nside, None)\\n s.smodel = s.model\\n \\n return self.get_global_sources(src_sel.skydir()), extended\",\n \"def prepare_data_for_g(self):\\n\\n paths = []\\n for i in self.root_nodes:\\n if np.random.rand() < config.update_ratio:\\n sample, paths_from_i = self.sample(i, self.trees[i], config.n_sample_gen, for_d=False)\\n if paths_from_i is not None:\\n paths.extend(paths_from_i)\\n # for each root, we generate 20 samples, each sample is equal to one path from root to that sample\\n # So, we will get maximum (num_root x 20) paths\\n # path is a list with length = (N x num_sample), with num_sample = 20\\n # paths =[[path_root1_to_sample1],[path_root1_to_sample2],....,[path_root1_to_sample20],\\n # [path_root2_to_sample1],[path_root2_to_sample2],....,[path_root2_to sample20]\\n # .\\n # .\\n # [path_rootN_to_sample1],[path_rootN_to_sample2],....,[path_rootN_to_sample20]]\\n # get_node_pairs_from_path\\n\\n node_pairs = list(map(self.get_node_pairs_from_path, paths))\\n # node_pairs = [[node pairs for path_root1_to_sample1],[node pairs for path_root1_to_sample2],....,[node pairs for path_root1_to_sample20],\\n # [node_pairs for path_root2_to_sample1],[node pairs for path_root2_to_sample2],....,[node pairs for path_root2_to sample20],\\n # .\\n # .\\n # [node pairs for path_rootN_to_sample1],[node pairs for path_rootN_to_sample2],....,[node pairs for path_rootN_to_sample20]]\\n\\n node_1 = []\\n node_2 = []\\n for i in range(len(node_pairs)):\\n for pair in node_pairs[i]:\\n node_1.append(pair[0])\\n node_2.append(pair[1])\\n # reward = self.sess.run(self.discriminator.reward,\\n # feed_dict={self.discriminator.node_id: np.array(node_1),\\n # self.discriminator.node_neighbor_id: np.array(node_2)})\\n reward = self.discriminator.forward(node_1, node_2)\\n return node_1, node_2, reward\",\n \"def bounded_bfs_paths(G,sources,max_depth=None):\\n\\t# Based on http://www.ics.uci.edu/~eppstein/PADS/BFS.py\\n\\t# by D. Eppstein, July 2004.\\n\\tvisited=set(sources)\\n\\tdepth=0\\n\\tstack = []\\n\\tfor source in sources:\\n\\t\\tstack.append((source,iter(G[source]),depth,[source]))\\n\\twhile stack:\\n\\t\\t# print stack\\n\\t\\tparent,children,last_depth,path = stack[0]\\n\\t\\tdepth=last_depth+1\\n\\t\\tif (max_depth) and (depth > max_depth):\\n\\t\\t\\tbreak\\n\\t\\ttry:\\n\\t\\t\\tchild = next(children)\\n\\t\\t\\t# if child not in visited:\\n#\\t\\t\\tyield parent,child\\n#\\t\\t\\tvisited.add(child)\\n\\t\\t\\tif child not in path :\\n\\t\\t\\t\\tyield path+[child]\\n\\t\\t\\t\\tstack.append((child,iter(G[child]),depth,path+[child]))\\n\\t\\texcept StopIteration:\\n\\t\\t\\tstack.pop(0)\",\n \"def reset(self):\\n\\t\\tself.globalQueue = PriorityQueue()\\n\\t\\tself.simTime = 0\\n\\t\\tself.sources = []\\n\\t\\tfor i in range(self.no_of_sources):\\n\\t\\t\\t# s = Source(random.random())#, transfer_rate = 4, packet_size = 100, bandwidth = 1000, switch = None)\\n\\t\\t\\ts = Source(random.random(), transfer_rate = self.source_tranfer_rate[i], packet_size = 100, bandwidth = self.source_bandwith[i], switch = None)\\n\\t\\t\\tself.sources.append(s)\\n\\t\\tself.switch = Switch(output_bandwidth =self.output_bandwidth, source_list = self.sources, queue_size = self.queue_size, sink = None)\\n\\t\\tself.switch.list_sources()\\n\\t\\tself.sink = Sink(switch =self.switch)\\n\\t\\t# connect the sink to the switch\\n\\t\\tself.switch.add_sink(self.sink)\\n\\t\\t# now we need to add the switch to the source\\n\\t\\tfor s in self.sources:\\n\\t\\t\\ts.connect_to_switch(self.switch)\\n\\t\\t## all connections have been done\\n\\t\\t# no packets and push into queue_size\\n\\t\\tinitial_events = []\\n\\t\\tfor s in self.sources:\\n\\t\\t\\te = s.Produce_Event0(self.simTime)\\n\\t\\t\\tinitial_events.append(e)\\n\\t\\t\\tself.globalQueue.put(e)\",\n \"def generateNumsets(G):\\n # paths = []\\n #\\n # path = [0]\\n # for edge in nx.dfs_edges(G, 0):\\n # if edge[0] == path[-1]:\\n # path.append(edge[1])\\n # else:\\n # paths.append(path)\\n # search_index = 2\\n # while search_index <= len(path):\\n # if edge[0] == path[-search_index]:\\n # path = path[:-search_index + 1] + [edge[1]]\\n # break\\n # search_index += 1\\n # else:\\n # raise Exception(\\\"Wrong path structure?\\\", path, edge)\\n # paths.append(path)\\n # return paths\\n\\n \\\"\\\"\\\"\\n Trying to use itertools LMAO\\n \\\"\\\"\\\"\\n # paths = []\\n #\\n # for path in itertools.combinations(G.nodes, 5):\\n # paths.append(path)\\n # return paths\\n\\n \\\"\\\"\\\"\\n Generating paths using graph\\n \\\"\\\"\\\"\\n paths = []\\n n = len(G.nodes)\\n for source in range(n):\\n for target in range(source+1, n):\\n paths.extend([path for path in nx.all_simple_paths(G, source=source, target=target)])\\n return paths\\n\\n # return paths\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6332378","0.60935616","0.5811239","0.560641","0.5514502","0.5492238","0.5380612","0.5344111","0.5344111","0.53399456","0.5291331","0.5245833","0.52410334","0.5200011","0.51825786","0.51523155","0.51386243","0.51315624","0.5101362","0.5068613","0.5018153","0.50158495","0.501156","0.50016","0.49956098","0.49911538","0.49850804","0.4983879","0.49826854","0.49777502","0.49758205","0.49661323","0.4962964","0.4958735","0.49538487","0.4906639","0.48991334","0.48957837","0.48909414","0.48855647","0.4880324","0.4880202","0.4876743","0.4874223","0.4872329","0.48625922","0.48619056","0.48607895","0.48569804","0.48548347","0.48546422","0.48523653","0.4851453","0.48511985","0.48484996","0.48478875","0.48400196","0.4826584","0.4826584","0.48178673","0.4813123","0.48091263","0.4808815","0.48077375","0.4807688","0.48074785","0.4794856","0.4793843","0.47925884","0.47918916","0.47894335","0.47790402","0.4771487","0.4768727","0.4760131","0.47417963","0.4740463","0.47395298","0.4738663","0.4735992","0.4732863","0.47324628","0.47258088","0.47216672","0.47115764","0.4707706","0.47067174","0.47058943","0.4705859","0.47040072","0.4688927","0.46887276","0.46859732","0.46854788","0.4684628","0.46803173","0.46715942","0.4666966","0.46662283","0.4665425"],"string":"[\n \"0.6332378\",\n \"0.60935616\",\n \"0.5811239\",\n \"0.560641\",\n \"0.5514502\",\n \"0.5492238\",\n \"0.5380612\",\n \"0.5344111\",\n \"0.5344111\",\n \"0.53399456\",\n \"0.5291331\",\n \"0.5245833\",\n \"0.52410334\",\n \"0.5200011\",\n \"0.51825786\",\n \"0.51523155\",\n \"0.51386243\",\n \"0.51315624\",\n \"0.5101362\",\n \"0.5068613\",\n \"0.5018153\",\n \"0.50158495\",\n \"0.501156\",\n \"0.50016\",\n \"0.49956098\",\n \"0.49911538\",\n \"0.49850804\",\n \"0.4983879\",\n \"0.49826854\",\n \"0.49777502\",\n \"0.49758205\",\n \"0.49661323\",\n \"0.4962964\",\n \"0.4958735\",\n \"0.49538487\",\n \"0.4906639\",\n \"0.48991334\",\n \"0.48957837\",\n \"0.48909414\",\n \"0.48855647\",\n \"0.4880324\",\n \"0.4880202\",\n \"0.4876743\",\n \"0.4874223\",\n \"0.4872329\",\n \"0.48625922\",\n \"0.48619056\",\n \"0.48607895\",\n \"0.48569804\",\n \"0.48548347\",\n \"0.48546422\",\n \"0.48523653\",\n \"0.4851453\",\n \"0.48511985\",\n \"0.48484996\",\n \"0.48478875\",\n \"0.48400196\",\n \"0.4826584\",\n \"0.4826584\",\n \"0.48178673\",\n \"0.4813123\",\n \"0.48091263\",\n \"0.4808815\",\n \"0.48077375\",\n \"0.4807688\",\n \"0.48074785\",\n \"0.4794856\",\n \"0.4793843\",\n \"0.47925884\",\n \"0.47918916\",\n \"0.47894335\",\n \"0.47790402\",\n \"0.4771487\",\n \"0.4768727\",\n \"0.4760131\",\n \"0.47417963\",\n \"0.4740463\",\n \"0.47395298\",\n \"0.4738663\",\n \"0.4735992\",\n \"0.4732863\",\n \"0.47324628\",\n \"0.47258088\",\n \"0.47216672\",\n \"0.47115764\",\n \"0.4707706\",\n \"0.47067174\",\n \"0.47058943\",\n \"0.4705859\",\n \"0.47040072\",\n \"0.4688927\",\n \"0.46887276\",\n \"0.46859732\",\n \"0.46854788\",\n \"0.4684628\",\n \"0.46803173\",\n \"0.46715942\",\n \"0.4666966\",\n \"0.46662283\",\n \"0.4665425\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.622782"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":24589,"cells":{"query":{"kind":"string","value":"Returns a set of flows st. there will be a single flow sourced from each node in the network with a destination randomly chosen from the set V / {s} where V is the set of nodes in the graph and s is the source node of the flow. Flows are equally distributed over the three shortest paths connecting the source node to the destination node."},"document":{"kind":"string","value":"def compute_equal_flow_allocations(target_graph, K=3):\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n flow_allocation_seed_number = 0xDEAD_BEEF\n np.random.seed(flow_allocation_seed_number)\n flows = []\n for node in target_graph.nodes:\n possible_destination_nodes = set(target_graph.nodes) - set([node])\n [destination_node] = np.random.choice(list(possible_destination_nodes), 1, replace=False)\n # shortest_paths = all_shortest_paths(target_graph, node, destination_node.item())\n shortest_paths = sorted(nx.all_simple_paths(target_graph, node, destination_node.item(),\n cutoff=3),\n key=lambda p: len(p))\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\n the_flow = Flow( source_node = node\n , destination_node = destination_node.item()\n , flow_tx_rate = 10.0\n , paths = k_shortest_paths\n , splitting_ratio = [1/K]*K\n )\n flows.append(the_flow)\n \n return flow_allocation_seed_number, flows"},"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_paths_for_flow(F, s, f):\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links","def get_paths_for_flow(F, s, f):\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links","def compute_path_hopping_flow_allocations(target_graph, K=3):\n flow_allocation_seed_number = 0xCAFE_BABE\n np.random.seed(flow_allocation_seed_number)\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n link_utilization = {(u, v): 0.0 for u, v in target_graph.edges}\n node_capacity = {u: 0.0 for u in target_graph.nodes}\n flows = []\n while True:\n source_node, destination_node = flow_selection_fn(target_graph.nodes, 2, replace=False)\n print(source_node, destination_node)\n\n shortest_paths = sorted(nx.all_simple_paths(target_graph, source_node, destination_node,\n cutoff=3),\n key=lambda p: len(p))\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\n\n # flow_tx_rate = np.random.uniform() * 10\n flow_tx_rate = 1.0\n # if node_capacity[source_node] + flow_tx_rate > LINK_CAPACITY:\n # break\n node_capacity[source_node] += flow_tx_rate\n capacity_was_exceeded = False \n for path in [nx.utils.pairwise(p_i) for p_i in k_shortest_paths]:\n for u, v in [sorted(h_i) for h_i in path]:\n flow_rate_per_subpath = flow_tx_rate / K\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\n capacity_was_exceeded = True\n break\n link_utilization[u, v] += flow_rate_per_subpath\n if capacity_was_exceeded:\n break\n\n if capacity_was_exceeded:\n break\n\n the_flow = Flow( source_node = source_node\n , destination_node = destination_node\n , flow_tx_rate = flow_tx_rate\n , paths = k_shortest_paths\n , splitting_ratio = [1.0/K]*K\n )\n flows.append(the_flow)\n return flows, link_utilization","def test_sources():\n g = Graph(from_list=[\n (1, 3, 1),\n (2, 4, 1),\n (2, 5, 1),\n (3, 5, 1),\n (4, 6, 1),\n (5, 6, 1),\n ])\n g.add_node(7)\n s = g.sources(5)\n e = {1, 2, 3}\n assert s == e\n\n s2 = g.sources(1)\n e2 = set()\n assert s2 == e2, s2\n\n s3 = g.sources(6)\n e3 = {1, 2, 3, 4, 5}\n assert s3 == e3\n\n s4 = g.sources(7)\n e4 = set()\n assert s4 == e4","def traverse_graph(F, f, s, t, u, sr):\n def get_paths_for_flow(F, s, f):\n \"\"\"\n RETURNS\n A set of outgoing links and corresponding splitting ratios for flow f\n at node s\n \"\"\"\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links\n \n if u == t:\n return [([t], sr)]\n\n outgoing_links = get_paths_for_flow(F, u, f)\n paths_to_t = []\n\n for ((current_node, next_hop), split_ratio) in outgoing_links:\n paths_from_u_to_t = traverse_graph(F, f, s, t, next_hop, split_ratio) \n paths_to_t.extend(paths_from_u_to_t)\n\n paths_to_t_with_u = []\n for path in paths_to_t:\n nodes, sr = path\n new_path = [u] + nodes\n paths_to_t_with_u.append((new_path, sr))\n\n return paths_to_t_with_u","def get_dfs(self, s):\n results = []\n # mark all the vertices as not visited\n visited = [False] * (len(self.graph))\n self._dfs_recursive(s, visited, results)\n return results","def max_flow(self, source, sink):\n\n path = self.valid_path(source, sink, [])\n\n while path:\n # get the maximum possible flow that can be taken from this path:\n max_flow = min([edge.capacity for edge in path])\n for edge in path:\n self.edges[edge] += max_flow\n path = self.valid_path(source, sink, [])\n\n # Compute all the flows from the neighbors of source:\n return sum([self.edges[edge] for edge in self.adjacents[source]])","def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\n demand: float,\n routing: np.ndarray) -> np.ndarray:\n edge_mapping = {edge: i for i, edge in\n enumerate(sorted(self.graph.edges))}\n\n link_utilisation = np.zeros(self.num_edges)\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\n node_flow[flow[0]] = demand\n\n to_explore = [flow[0]]\n while to_explore:\n current_node = to_explore.pop(0)\n current_flow = node_flow[current_node]\n\n # this is the flow destination node so we absorb all flow\n if current_node == flow[1]:\n node_flow[current_node] = 0.0\n continue\n\n # push the flow at this node over all edges\n for edge in self.graph.out_edges(current_node):\n edge_index = edge_mapping[edge]\n ratio = routing[edge_index]\n flow_to_send = ratio * current_flow\n # only send flow if greater than epsilon (so no 'infinite' loops)\n if flow_to_send > 1.e-8:\n node_flow[edge[1]] += ratio * current_flow\n # all important step, update our output\n link_utilisation[edge_index] += ratio * current_flow\n # have updated the dst so add it to the list of things to do\n to_explore.append(edge[1])\n # we've moved all the flow from this node now, so reset back to zero\n node_flow[current_node] = 0.0\n\n return link_utilisation","def ford_fulkerson_algorithm(graph: np.ndarray, source: int, sink: int) -> np.ndarray:\r\n\r\n residual_graph = copy.deepcopy(graph)\r\n row = len(residual_graph)\r\n parent = [-1] * row\r\n max_flow = 0\r\n\r\n if source == sink or sink < 0 or source < 0 or source >= row or sink >= row:\r\n raise WrongInputException('Wrong input source/sink vertice(s)')\r\n\r\n while bfs(residual_graph, row, source, sink, parent):\r\n\r\n path_flow = float(\"Inf\")\r\n s = sink\r\n while s != source:\r\n path_flow = min(path_flow, residual_graph[parent[s]][s])\r\n s = parent[s]\r\n\r\n max_flow += path_flow\r\n\r\n v = sink\r\n while v != source:\r\n u = parent[v]\r\n residual_graph[u][v] -= path_flow\r\n residual_graph[v][u] += path_flow\r\n v = parent[v]\r\n print(\"Max flow: %d\" % max_flow)\r\n\r\n return residual_graph","def compute_greedy_flow_allocations( target_graph\n , flow_selection_fn\n , seed_number=DEFAULT_SEED_NUMBER):\n\n flow_allocation_seed_number = seed_number\n np.random.seed(flow_allocation_seed_number)\n\n link_utilization = {tuple(sorted(link_tuple)): 0.0 for link_tuple in target_graph.edges}\n flows = []\n\n while True:\n capacity_was_exceeded = False\n\n source_node, destination_node = flow_selection_fn(target_graph.nodes)\n flow_tx_rate = np.random.uniform(FLOW_TX_RATE_LOWER_BOUND, FLOW_TX_RATE_UPPER_BOUND)\n\n connecting_paths = list(node_disjoint_paths(target_graph, source_node, destination_node))\n disjoint_path_count = len(connecting_paths)\n flow_rate_per_subpath = flow_tx_rate / disjoint_path_count\n for path in [nx.utils.pairwise(p_i) for p_i in connecting_paths]:\n for u, v in [tuple(sorted(t_i)) for t_i in path]:\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\n capacity_was_exceeded = True\n break\n link_utilization[u, v] += flow_rate_per_subpath\n if capacity_was_exceeded:\n break\n if capacity_was_exceeded:\n break\n\n the_flow = Flow( source_node = source_node\n , destination_node = destination_node\n , flow_tx_rate = flow_tx_rate\n , paths = connecting_paths\n , splitting_ratio = [1.0/disjoint_path_count]*disjoint_path_count\n )\n flows.append(the_flow)\n return flows, link_utilization","def ListAllFlows(client_id: str) -> List[rdf_flow_objects.Flow]:\n return data_store.REL_DB.ReadAllFlowObjects(client_id=client_id)","def dfs(self, s):\n g = Graph(attr={DIRECTED: True})\n adjacent_type = '+' if DIRECTED in self.attr and self.attr[\n DIRECTED] else None\n # Insert s root node in stack \n stack = collections.deque()\n # Initial node does not have origin, it is represented by # \n stack.append(('#', s))\n\n while (len(stack) > 0):\n (source, target) = stack.pop()\n w = self.get_vertex(target)\n if DISCOVERED not in w.attributes or w.attributes[\n DISCOVERED] is False:\n w.attributes[DISCOVERED] = True\n g.add_vertex(w)\n if (source != '#'):\n g.add_edge(edge.Edge(source, w.id), True)\n for e in self.get_adjacent_vertices_by_vertex(w.id,\n adjacent_type):\n stack.append((w.id, e))\n return g","def dijkstra(vs, es, s, stop = None):\n initialize_single_source(vs, es, s)\n key = lambda x: -1 * x._ss_d\n Q = pq(vs)\n edict = defaultdict(set)\n for e in es:\n edict[e.v1].add(e)\n edict[e.v2].add(e)\n\n for i in range(len(vs)):\n # min path to u is determined at end of loop\n u = Q.pop()\n for e in edict[u]:\n v = e.v1 if e.v1 != u else e.v2\n relax(u, v, e, Q)\n if u == stop: return \n \n result = [v._ss_d for v in vs]\n return result","def dijkstra(self, s, t):\n l = []\n dist = {}\n prev = {}\n discovered = {}\n for v in self.get_vertices():\n dist[v] = float('inf')\n prev[v] = None\n discovered[v] = False\n dist[s] = 0\n l.append((s, dist[s]))\n while len(l) != 0:\n u = min(l, key=lambda x: x[1])\n l.remove(u)\n u = u[0]\n discovered[u] = True\n if u == t:\n break\n for v in self.get_adjacent_vertices_by_vertex(u):\n if not discovered[v]:\n alt = dist[u] + self.get_edge((u, v)).attr[\"WEIGHT\"]\n if alt < dist[v]:\n dist[v] = alt\n prev[v] = u\n l.append((v, dist[v]))\n # Create a graph according to visited nodes store in prev array\n u = t\n g = Graph(attr={DIRECTED: True})\n while u is not None:\n g.add_vertex(vertex.Vertex(u, {\"WEIGHT\": dist[u]}))\n if prev[u] is not None:\n g.add_vertex(vertex.Vertex(prev[u], {\"WEIGHT\": dist[prev[u]]}))\n g.add_edge(edge.Edge(prev[u], u))\n u = prev[u]\n else:\n break\n return g","def dfs_edges_generator(graph, source, reverse=...):\n ...","def set_random_session(self, G, degree_s):\n sorted_nodes = nx.topological_sort(G)\n num_nodes = G.number_of_nodes()\n\n # create sources and destinations of each of the sections\n # name the nodes to be the last 4 numbers\n srcs = [num_nodes, num_nodes + 1]\n dsts = [num_nodes + 2, num_nodes + 3]\n\n end_idx = int(0.3 * len(sorted_nodes))\n end_idx = max(end_idx, 2)\n for i in range(2):\n s = srcs[i]\n t = dsts[i]\n reachables = []\n iter_num = 0\n\n while len(reachables) == 0:\n iter_num += 1\n if iter_num > 100:\n end_idx = end_idx * 2\n\n # pick an entry point from the first 30%\n entry_point = random.choice(sorted_nodes[:end_idx])\n # print \"Source \", i\n # print \"candidates: \", sorted_nodes[:end_idx]\n # print \"entry point: \", entry_point\n # print \"all nodes: \", G.nodes()\n\n # pick a random point from the reachables\n reachables = nx.shortest_path(G, entry_point)\n del reachables[entry_point]\n #print \"reachables: \", reachables\n reachables = reachables.keys()\n\n exit_point = random.choice(reachables)\n #print \"exit_point: \", exit_point\n\n if degree_s[i]:\n G.add_edge(s, entry_point, weight=degree_s[i])\n G.add_edge(exit_point, t, weight=degree_s[i])\n else:\n # figure out the out_degree of entry point\n out_degree = np.sum(G[u][v]['weight'] for u,v in G.out_edges(entry_point))\n G.add_edge(s, entry_point, weight=out_degree)\n\n # figure out the int_degree of exit point\n in_degree = np.sum(G[u][v]['weight'] for u,v in G.in_edges(exit_point))\n G.add_edge(exit_point, t, weight=in_degree)\n\n edges = G.edges()\n for u, v in edges:\n par_num = int(G[u][v]['weight'])\n for i in range(par_num):\n self.add_edge(u, v)\n\n # set indices etc\n self.set_sources(srcs)\n self.set_destinations(dsts)\n self.set_indices()\n #print \"number of nodes: \" + str(self.number_of_nodes())\n #print \"number of edges: \" + str(self.number_of_edges())","def sorted_nodes(self):\r\n def is_source(node, connections):\r\n for connection in connections:\r\n if node == connection[1]:\r\n return False\r\n return True\r\n\r\n def source_connections(node, connections):\r\n conns = set()\r\n for connection in connections:\r\n if node == connection[0]:\r\n conns.add(connection)\r\n return conns\r\n\r\n nodes = set(self.nodes.values())\r\n connections = self.connections.copy()\r\n sorted_nodes = []\r\n\r\n # Find source nodes:\r\n source_nodes = set([n for n in nodes if is_source(n, connections)])\r\n\r\n # while S is non-empty do\r\n while source_nodes:\r\n # remove a node n from S\r\n node = source_nodes.pop()\r\n # insert n into L\r\n sorted_nodes.append(node)\r\n\r\n # for each node m with an edge e from n to m do\r\n s_connections = source_connections(node, connections)\r\n for connection in s_connections:\r\n # remove edge e from the graph\r\n m = connection[1]\r\n connections.remove(connection)\r\n # if m has no other incoming edges then\r\n # insert m into S\r\n if is_source(m, connections):\r\n source_nodes.add(m)\r\n\r\n # if graph has edges then\r\n # output error message (graph has at least one cycle)\r\n # else\r\n # output message (proposed topologically sorted order: L)\r\n\r\n if connections:\r\n raise Exception(\"Steram has at least one cycle (%d connections left of %d)\" % (len(connections), len(self.connections)))\r\n\r\n return sorted_nodes","def find_flows(flows,\n source_query,\n target_query,\n flow_query=None,\n ignore_edges=None):\n if flow_query is not None:\n flows = flows[eval_selection(flows, '', flow_query)]\n\n if source_query is None and target_query is None:\n raise ValueError('source_query and target_query cannot both be None')\n\n elif source_query is None and target_query is not None:\n qt = eval_selection(flows, 'target', target_query)\n qs = (~eval_selection(flows, 'source', target_query) &\n ~flows.index.isin(ignore_edges or []))\n\n elif source_query is not None and target_query is None:\n qs = eval_selection(flows, 'source', source_query)\n qt = (~eval_selection(flows, 'target', source_query) &\n ~flows.index.isin(ignore_edges or []))\n\n else:\n qs = eval_selection(flows, 'source', source_query)\n qt = eval_selection(flows, 'target', target_query)\n\n f = flows[qs & qt]\n if source_query is None:\n internal_source = None\n else:\n internal_source = flows[qs & eval_selection(flows, 'target',\n source_query)]\n if target_query is None:\n internal_target = None\n else:\n internal_target = flows[qt & eval_selection(flows, 'source',\n target_query)]\n\n return f, internal_source, internal_target","def DRBFS(self, flow, edge_mark):\n\t\t# Distance flag for each node\n\t\td = {v:float('inf') for v in self.topo.nodes}\n\t\t# Parent node for each node\n\t\tpa = {v:-1 for v in self.topo.nodes}\n\t\t# Request info\n\t\ts = flow[0]\n\t\tt = flow[1]\n\n\t\t# BFS to find a min-hop path\n\t\tqueue = [s]; hdr = 0; d[s] = 0\n\t\twhile hdr < len(queue):\n\t\t\tu = queue[hdr]\n\t\t\thdr += 1\n\n\t\t\tfor v in self.topo.topo.neighbors(u):\n\t\t\t\tif edge_mark[(u, v)] or d[v] <= d[u] + 1:\n\t\t\t\t\tcontinue\n\t\t\t\tqueue.append(v)\n\t\t\t\td[v] = d[u] + 1\n\t\t\t\tpa[v] = u\n\t\t\t\tif v == t:\n\t\t\t\t\t# This is because when BFS on edges, the first time reaching t meaning the smallest hop it can be reached\n\t\t\t\t\thdr = len(queue)\n\t\t\t\t\tbreak\n\n\t\tif d[t] == float('inf'):\n\t\t\treturn False\n\n\t\tp = [t]; v = t\n\t\twhile v != s and v != -1:\n\t\t\tv = pa[v]\n\t\t\tp.append(v)\n\t\tp.reverse()\n\n\t\treturn p","def objective(graph, flows):\n\n G = graph.copy()\n rules = {}\n flows.sort(key=lambda a: a[1], reverse=True)\n\n for flow,demand in flows:\n src = get_host_from_ip(G, flow.nw_src)\n dst = get_host_from_ip(G, flow.nw_dst)\n\n if not (src and dst):\n continue\n if not (src in G.nodes() and dst in G.nodes()):\n continue\n\n path = widest_path(G, src, dst)\n\n hops = []\n for a,b in pairwise(path):\n hops.append(Hop(dpid=int(a[1:]), port=G.edge[a][b]['port']))\n G.edge[a][b]['capacity'] -= demand\n G.edge[b][a]['capacity'] -= demand\n\n rules[flow] = hops\n\n return rules","def get_routing_solution(self):\n G = self.base_digraph\n s1 = self.sources[0]\n s2 = self.sources[1]\n t1 = self.destinations[0]\n t2 = self.destinations[1]\n\n try:\n m = Model('routing')\n m.setParam('OutputFlag', False)\n\n # variables,\n # We have one variable per edge per session\n # e is the dict of dict for the variables\n e = {}\n r = {}\n for i in [1,2]:\n e[i] = {}\n r[i] = m.addVar()\n for u,v in G.edges():\n e[i][u,v] = m.addVar(lb=0)\n\n m.update()\n\n obj = quicksum(r.values())\n m.setObjective(obj, GRB.MAXIMIZE)\n\n # constraints\n # 1. conservations of flow at all intermediate nodes\n # 2. capacity constraints for each edge\n\n for u,v in G.edges():\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\n\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\n\n for n in G.nodes():\n if n not in [s1, s2, t1, t2]:\n for i in [1, 2]:\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\n m.addConstr(inflow == outflow)\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n for u, v in G.edges():\n G[u][v]['Routing'] = {}\n G[u][v]['Routing'][1] = e[1][u,v].x\n G[u][v]['Routing'][2] = e[2][u,v].x\n return (m.objVal, r[1].x, r[2].x)\n else:\n # something went wrong...err...\n print \"Something was wrong, no optimal solution obtained\"\n return None, None, None\n\n except GurobiError:\n Print ('Error Report from Gurobi')","def make_flow_graph(interaction_logs):\n G = pgv.AGraph(directed=True)\n\n for module_id in interaction_logs['module_id'].unique():\n G.add_node(module_id)\n\n E = defaultdict(set)\n grouped = interaction_logs.groupby('user_id')\n for user_id, group in grouped:\n module_ids_in_student_path = group['module_id']\n for source_node, target_node in zip(module_ids_in_student_path[:-1], module_ids_in_student_path[1:]):\n if source_node != target_node: # stationary\n E[(source_node, target_node)] |= {user_id}\n\n for (source_node, target_node), students_that_made_transition in E.iteritems():\n G.add_edge(\n source_node,\n target_node,\n weight=len(students_that_made_transition))\n\n return G","def _compute_flows(paths):\n assert isinstance(paths, list)\n\n # allocate memory\n flows = np.zeros([len(paths), FLAGS.target_height, FLAGS.target_width, 2],\n dtype=np.float32)\n\n # load all images\n pbar = ProgressBar(max_value=len(paths))\n for i in range(len(paths)-1):\n im1 = skimage.io.imread(paths[i])\n im2 = skimage.io.imread(paths[i+1])\n\n im1 = cv2.cvtColor(im1, cv2.COLOR_RGB2GRAY)\n im2 = cv2.cvtColor(im2, cv2.COLOR_RGB2GRAY)\n im1 = skimage.transform.resize(\n im1, [FLAGS.target_height, FLAGS.target_width], preserve_range=True,\n mode='constant', anti_aliasing=True)\n im2 = skimage.transform.resize(\n im2, [FLAGS.target_height, FLAGS.target_width], preserve_range=True,\n mode='constant', anti_aliasing=True)\n flow = cv2.calcOpticalFlowFarneback(\n im1, im2, flow=None, pyr_scale=0.5, levels=3, winsize=15,\n iterations=3, poly_n=5, poly_sigma=1.2, flags=0)\n\n # store images\n flows[i] = flow\n pbar.update(i)\n\n # Replicate the flow for last frame\n flows[-1] = flow\n return flows","def step(nodes, outputs, edges):\n flowed = []\n for node_name in nodes.copy():\n if node_name in flowed:\n continue\n if len(nodes[node_name]) == 2:\n if node_name in flowed:\n continue\n node = [int(value) for value in nodes[node_name]]\n low_value, high_value = min(node), max(node)\n low_flow, high_flow = edges[node_name] \n low_dictionary, low_node_name = low_flow\n high_dictionary, high_node_name = high_flow\n low_node = low_dictionary.get(low_node_name, tuple())\n high_node = high_dictionary.get(high_node_name, tuple())\n low_dictionary[low_node_name] = low_node + (str(low_value),)\n high_dictionary[high_node_name] = high_node + (str(high_value),)\n nodes[node_name] = tuple()\n if low_dictionary is nodes:\n flowed.append(low_node_name)\n if high_dictionary is nodes:\n flowed.append(high_node_name)\n return nodes, outputs, edges","def find_all_cycles(s,graph):\n\n grph = u.edge_to_list_dict(graph)\n node_cnt = len(grph)\n k = z.Int(\"k\")\n syms = [z.Int('node%s'%i) for i in range(node_cnt)]\n\n # s.add(syms[0] == 0) # start node is a 0\n s.add(k < node_cnt)\n s.add(k > 1)\n\n o = z.Optimize()\n\n # for source, sinks in sgraph.s_adj_list():\n for i in range(node_cnt):\n s.add(syms[i] >= 0)\n s.add(syms[i] <= k)\n s.add(z.Or([syms[j] == ((syms[i] + 1) % k) for j in grph[i]]) == (syms[i] == 0))\n\n\n r = []\n m = []\n\n # o.minimize(z.Sum([syms[i] for i in range(node_cnt)]))\n s.add(z.Product([syms[i] for i in range(node_cnt)]) == 0)\n done = False\n while not done:\n if s.check() == z.sat:\n m = s.model()\n r.append(m)\n s.add(k != m[k])\n else:\n done = True\n\n return r","def generateNumsets(G):\n # paths = []\n #\n # path = [0]\n # for edge in nx.dfs_edges(G, 0):\n # if edge[0] == path[-1]:\n # path.append(edge[1])\n # else:\n # paths.append(path)\n # search_index = 2\n # while search_index <= len(path):\n # if edge[0] == path[-search_index]:\n # path = path[:-search_index + 1] + [edge[1]]\n # break\n # search_index += 1\n # else:\n # raise Exception(\"Wrong path structure?\", path, edge)\n # paths.append(path)\n # return paths\n\n \"\"\"\n Trying to use itertools LMAO\n \"\"\"\n # paths = []\n #\n # for path in itertools.combinations(G.nodes, 5):\n # paths.append(path)\n # return paths\n\n \"\"\"\n Generating paths using graph\n \"\"\"\n paths = []\n n = len(G.nodes)\n for source in range(n):\n for target in range(source+1, n):\n paths.extend([path for path in nx.all_simple_paths(G, source=source, target=target)])\n return paths\n\n # return paths","def flowers(self):\n return self._flowers","def possible(self):\n return [tuple(path) for path in nx.all_shortest_paths(self._gpm.Graph, source=self.source, target=self.target)]","def min_path(vs, es, source, target):\n dijkstra(vs, es, source, stop = target)\n test = target\n result = []\n while test != source:\n e = test._ss_edge\n result.append(e)\n test = e.v1 if e.v1 != test else e.v2\n assert test == source and test._ss_edge is None\n return result[::-1]","def get_all_pairs(G):\n # list all (start,dest) pairs between which the route must be computed\n pairs_list = [(start, dest) for dest in G.nodes for start in G.nodes]\n\n # shuffle all elements in-place\n random.shuffle(pairs_list)\n\n # generate a set from the list\n pairs_set = set(pairs_list)\n\n return pairs_list, pairs_set","def stochastic_event_set(\n sources, source_site_filter=filters.source_site_noop_filter):\n for source, s_sites in source_site_filter(sources):\n try:\n for rupture in source.iter_ruptures():\n for i in range(rupture.sample_number_of_occurrences()):\n yield rupture\n except Exception as err:\n etype, err, tb = sys.exc_info()\n msg = 'An error occurred with source id=%s. Error: %s'\n msg %= (source.source_id, str(err))\n raise_(etype, msg, tb)","def _load_flows(paths):\n assert isinstance(paths, list)\n # allocate memory\n flows = np.zeros([len(paths), FLAGS.target_height, FLAGS.target_width, 2],\n dtype=np.float32)\n\n # load all flows\n pbar = ProgressBar(max_value=len(paths)-1)\n for i in range(len(paths)):\n # Load flow\n flow = np.load(paths[i])\n\n # Central crop flow\n h, w, _ = flow.shape\n left = (w - FLAGS.target_width) // 2\n top = (h - FLAGS.target_height) // 2\n right = left + FLAGS.target_width\n bottom = top + FLAGS.target_height\n flow = flow[left:right, top:bottom, :]\n\n # Store flow\n flows[i] = flow\n pbar.update(i)\n return flows","def showFlow(self):\r\n def edgesFromVertex(u):\r\n \"\"\"\r\n Represents the flow across the given vertex.\r\n \"\"\"\r\n edgeRepresentation = lambda v: f\"({u}, {v}, {self.getCapacity((u, v))}, {self.getFlow((u,v))})\"\r\n return \", \".join(map(edgeRepresentation, sorted(self.adjacent[u])))\r\n\r\n def adjacencyLists():\r\n \"\"\"\r\n Represents the flow across all relevant vertices.\r\n \"\"\"\r\n anyNeighbor = lambda u: any(self.neighbors(u))\r\n verticesWithNeighbors = filter(anyNeighbor, sorted(self.vertices()))\r\n return map(edgesFromVertex, verticesWithNeighbors)\r\n\r\n return print(\"\\n\".join(adjacencyLists()))","def generate_graph(size, number_of_clusters, minimal_size):\n base_list = list(range(size))\n result_list = []\n random.shuffle(base_list)\n for i in range(number_of_clusters - 1):\n size = random.randint(minimal_size, len(base_list) - (number_of_clusters - i - 1) * minimal_size)\n cluster = []\n for n in range(size):\n actual = random.choice(base_list)\n base_list.remove(actual)\n cluster.append(actual)\n result_list.append(strongly_connect(cluster))\n result_list.append(strongly_connect(base_list))\n\n while len(result_list) < 5:\n result_list.append([])\n\n print(sorted([len(i) for i in result_list], reverse=True)[:5])\n\n return weak_connect_graph(result_list)","def __generate_all_shortest_paths(self,cutoff = 10):\n if cutoff < 1:\n cutoff = 10\n self.__logger.info(\"cutoff value must be a positive integer. Set back to default value: 10\")\n\n all_pair_shortest_paths = nx.all_pairs_shortest_path(self.G, cutoff=cutoff)\n for item in all_pair_shortest_paths:\n from_node = item[0]\n paths = item[1]\n for destination,path in paths.items():\n yield (len(path),path)","def bfs(self, s, visit=None):\n visited = set()\n\n # initialize the queue with the start vertex\n queue = deque([s])\n \n # loop until the queue is empty\n while queue:\n\n # get the next vertex\n v = queue.popleft()\n\n # skip it if it's already visited\n if v in visited: continue\n\n # mark it visited, then invoke the visit function\n visited.add(v)\n if visit: visit(v)\n\n # add its out vertices to the queue\n queue.extend(self.out_vertices(v))\n\n # return the visited vertices\n return visited","def shortestPath(self, source, target):\n dist = {}\n prev = {}\n q = []\n for y,a in enumerate(self.sm):\n for x,b in enumerate(self.sm[y]):\n dist[(x,y)] = sys.maxint\n prev[(x,y)] = None\n q.append((x,y))\n dist[source] = 0\n\n while len(q) is not 0:\n # find the node with minimum value (u)\n d = deepcopy(dist)\n while True:\n b = dict(map(lambda item: (item[1],item[0]), d.items()))\n u = b[min(b.keys())]\n if u not in q:\n d.pop(u)\n else:\n break\n\n if dist[u] == sys.maxint: # remaining nodes are inaccessible\n break\n\n q.remove(u)\n\n\n if u == target: # target found\n break\n\n for v in self.getNeighbors(u):\n alt = dist[u] + 1\n if alt < dist[v]:\n dist[v] = alt\n prev[v] = u\n\n s = []\n u = target\n while prev[u] is not None:\n s.append(u)\n u = prev[u]\n s.reverse()\n\n return s","def dijkstra_tree(self, s):\n l = []\n dist = {}\n prev = {}\n discovered = {}\n g = Graph(attr={DIRECTED: True})\n g.add_vertex(vertex.Vertex(s, {\"WEIGHT\": 0}))\n for v in self.get_vertices():\n dist[v] = float('inf')\n prev[v] = None\n discovered[v] = False\n dist[s] = 0\n l.append((s, dist[s]))\n while len(l) != 0:\n u = min(l, key=lambda x: x[1])\n l.remove(u)\n u = u[0]\n discovered[u] = True\n for v in self.get_adjacent_vertices_by_vertex(u):\n if not discovered[v]:\n alt = dist[u] + self.get_edge((u, v)).attr[\"WEIGHT\"]\n if alt < dist[v]:\n dist[v] = alt\n prev[v] = u\n l.append((v, dist[v]))\n g.add_vertex(vertex.Vertex(v, {\"WEIGHT\": dist[v]}))\n g.add_edge(edge.Edge(u, v, {\"WEIGHT\": dist[v]}))\n\n return g","def bfs (graph, src, tgt):\n\n if not graph.has_key(src):\n raise AttributeError(\"The source '%s' is not in the graph\" % src)\n if not graph.has_key(tgt):\n raise AttributeError(\"The target '%s' is not in the graph\" % tgt)\n\n parents = {src: None}\n queue = deque([src])\n while queue:\n node = queue.popleft()\n for neighbor in graph[node]:\n if neighbor not in parents:\n parents[neighbor] = node\n queue.append(neighbor)\n if node == tgt:\n break\n\n path = [tgt]\n while parents[tgt] is not None:\n path.insert(0, parents[tgt])\n tgt = parents[tgt]\n\n return path","def shortest_route(self, src, dest):\n\n # Dijkstra with unusual start condition to prevent src -> src == 0 distance\n x_in = set()\n a = defaultdict(lambda: float('inf'))\n v = self.V.copy()\n\n for node, cost in self.G[src].items():\n a[node] = cost\n x_in.add(node)\n v.remove(node)\n\n while x_in != self.V:\n mn = float('inf')\n new = None\n for x in x_in:\n for node, cost in self.G[x].items():\n if node in v:\n if (a[x] + cost) < mn: # optimize large/dense G with pri. q\n mn = a[x] + cost\n new = (x, node, cost)\n if new is None:\n break\n x, node, cost = new\n x_in.add(node)\n v.remove(node)\n a[node] = a[x] + cost\n return a[dest]","def sens_flow_jsons(contexts: [{}], filter_flow) -> []:\n jsons = []\n for context in contexts:\n context_dir = context['dir']\n logger.debug(context_dir)\n for root, dirs, files in os.walk(context_dir):\n for file in files:\n if not file.endswith('_sens_http_flows.json'):\n continue\n with open(os.path.join(root, file), 'r', encoding=\"utf8\", errors='ignore') as infile:\n flows = json.load(infile)\n for flow in flows:\n if not filter_flow(flow):\n # The ground truth label, which is defined by \"context\" label.\n flow['real_label'] = context['label']\n jsons.append(flow)\n logger.info('The number of flows: %d', len(jsons))\n return jsons","def _pfs_nodes(cls, graph, source, size, priority):\n if size < 1:\n return iter(())\n\n # use min-heap to implement (max) priority queue\n # use insertion order to break priority tie\n queue = []\n counter = itertools.count()\n push = lambda priority, node: heappush(queue, (-priority, next(counter), node))\n pop = partial(heappop, queue)\n\n visited = set()\n enqueued = set()\n push(priority(source), source)\n\n while queue and len(visited) < size:\n _, _, node = pop()\n\n if node in visited:\n continue\n\n visited.add(node)\n\n for neighbor in graph[node]:\n if neighbor not in enqueued:\n enqueued.add(neighbor)\n push(priority(neighbor), neighbor)\n\n return iter(visited)","def get_flow_6frames(self, flows_forward, flows_backward, flows_forward2, flows_backward2):\n d = flows_forward2[0].shape[1]\n flows_backward3 = []\n for flows, flows2 in zip(flows_backward, flows_backward2):\n flow_list = []\n for i in range(d - 1, 0, -1):\n flow_n1 = flows2[:, i - 1, :, :, :]\n flow_n2 = flows[:, i + 1, :, :, :]\n flow_list.insert(0, flow_n1 + flow_warp(flow_n2, flow_n1.permute(0, 2, 3, 1)))\n flows_backward3.append(torch.stack(flow_list, 1))\n flows_forward3 = []\n for flows, flows2 in zip(flows_forward, flows_forward2):\n flow_list = []\n for i in range(2, d + 1):\n flow_n1 = flows2[:, i - 1, :, :, :]\n flow_n2 = flows[:, i - 2, :, :, :]\n flow_list.append(flow_n1 + flow_warp(flow_n2, flow_n1.permute(0, 2, 3, 1)))\n flows_forward3.append(torch.stack(flow_list, 1))\n return flows_backward3, flows_forward3","def flows(self, flows):\n\n self._flows = flows","def get_reachable_nodes(self, source: Node) -> Set[Node]:\n nodes_found: Set[Node] = {source}\n queue = [source]\n while queue:\n v = queue.pop()\n for e in v.outgoing_edges:\n if e.node_to not in nodes_found:\n nodes_found.add(e.node_to)\n queue.append(e.node_to)\n return nodes_found","def get_all_network_graphs(list_mtfs):\n list_graphs = []\n \n for mtf in list_mtfs:\n list_graphs.append(get_network_graph(mtf))\n \n return list_graphs","def generate(\n self,\n num_nodes_src_set: int,\n num_nodes_dst_set: int,\n num_edges_src_dst: int,\n num_edges_dst_src: int,\n is_directed: bool,\n return_node_ids: bool = False,\n transform_graph: bool = True,\n *args,\n **kwargs,\n ):\n raise NotImplementedError()","def get_flows(self, num_flows_per_entry):\n flows = []\n for tenant in self._tenants:\n for contract in tenant.get_children(only_class=Contract):\n providing_epgs = contract.get_all_providing_epgs()\n consuming_epgs = contract.get_all_consuming_epgs()\n for providing_epg in providing_epgs:\n vlan_ifs = providing_epg.get_all_attached(L2Interface)\n if len(vlan_ifs):\n providing_vlan = vlan_ifs[0].encap_id\n phys_ifs = vlan_ifs[0].get_all_attached(Interface)\n if len(phys_ifs):\n providing_phys_if = phys_ifs[0].name\n for consuming_epg in consuming_epgs:\n vlan_ifs = consuming_epg.get_all_attached(L2Interface)\n if len(vlan_ifs):\n consuming_vlan = vlan_ifs[0].encap_id\n phys_ifs = vlan_ifs[0].get_all_attached(Interface)\n if len(phys_ifs):\n consuming_phys_if = phys_ifs[0].name\n if providing_vlan == consuming_vlan and providing_phys_if == consuming_phys_if:\n # Skip this case since traffic would be switched outside fabric\n continue\n for filter_entry in contract.get_all_filter_entries():\n for i in range(0, num_flows_per_entry):\n flow = Flow()\n flow.ethertype = filter_entry.etherT\n if flow.ethertype == 'arp':\n flow.arp_opcode = filter_entry.arpOpc\n flow.populate_random_ip_addresses()\n elif flow.ethertype == 'ip':\n flow.populate_random_ip_addresses()\n flow.proto = filter_entry.prot\n if flow.proto == '6' or flow.proto == '17':\n dFromPort = int(filter_entry.dFromPort)\n dToPort = int(filter_entry.dToPort)\n sFromPort = int(filter_entry.sFromPort)\n sToPort = int(filter_entry.sToPort)\n if dFromPort == 0:\n dFromPort = 1\n dToPort += 1\n if sFromPort == 0:\n sFromPort = 1\n sToPort += 1\n if dToPort > 65534:\n dToPort = 65534\n if sToPort > 65534:\n sToPort = 65534\n flow.dport = str(random_number(dFromPort,\n dToPort))\n flow.sport = str(random_number(sFromPort,\n sToPort))\n if flow.proto == '6':\n flow.tcp_rules = filter_entry.tcpRules\n flow.svlan = providing_vlan\n flow.dvlan = consuming_vlan\n flow.src_intf = providing_phys_if\n flow.dst_intf = consuming_phys_if\n\n # Is the flow expected to succeed ?\n flow.expected_action = 'drop'\n providing_bd = providing_epg.get_bd()\n consuming_bd = consuming_epg.get_bd()\n if providing_bd and consuming_bd:\n if providing_bd == consuming_bd:\n if providing_bd.get_context() == consuming_bd.get_context():\n flow.expected_action = 'permit'\n flow.populate_random_mac_addresses()\n flows.append(flow)\n return flows","def ssf(n, N_max = 6, E_max = 4, time_total = 100 ):\n\n G = nx.DiGraph()\n G.add_edge( 0, 1, time_stamp = 1)\n\n # List of existing nodes, with nodes repeated once for each adjacent edge\n repeated_nodes = [0, 1]\n\n # compute discrete bins for nodes \n DistNodes = _get_distribution( N_max, 0 )\n # compute discrete bins for edges\n DistLinks = _get_distribution( E_max, 1 )\n \n # Start adding the other n - 2 nodes.\n N_current = time_current = 2\n while N_current < n and time_current < time_total + 1:\n # preferential attachment\n N_current = _preferential_attachment( DistNodes, DistLinks, N_current,\n time_total, time_current, n, repeated_nodes, G )\n time_current += 1\n \n# print(time_current, N_current)\n return G","def run_dfs(self,s):\n if self.verbose: print('entering run_dfs with s = ',s)\n new_states = [self.succ(s,a) for a in self.actions(s)]\n results = []\n\n for ns in new_states:\n if self.verbose: print('considering new state = ',ns)\n end = self.is_end(ns)\n if end:\n result = self.result(ns)\n if result is not None:\n results.append(result)\n else:\n results += self.run_dfs(ns)\n return results","def bfs(graph, source):\n visited = [False] * len(graph.graph)\n print(visited)\n\n result = \"\"\n queue = []\n\n queue.append(source)\n visited[source] = True\n\n while queue:\n source = queue.pop(0)\n result += str(source)\n\n while graph.graph[source] is not None:\n data = graph.graph[source].vertex\n if not visited[data]:\n queue.append(data)\n visited[data] = True\n graph.graph[source] = graph.graph[source].next\n return result","def compute_shortest_routes(start_ids, dest_ids, G):\n return ox.distance.shortest_path(G, start_ids, dest_ids, weight='travel_time', cpus=6)","def get_all_sghop_info (nffg, return_paths=False):\n sg_map = {}\n for i in nffg.infras:\n for p in i.ports:\n for fr in p.flowrules:\n # if fr.external:\n # continue\n if fr.id not in sg_map:\n # The path is unordered!!\n path_of_shop = []\n flowclass = NFFGToolBox._extract_flowclass(fr.match.split(\";\"))\n sg_map[fr.id] = [None, None, flowclass, fr.bandwidth, fr.delay]\n # We have to find the BEGINNING of this flowrule sequence.\n inbound_link = NFFGToolBox._find_infra_link(nffg, p, outbound=False,\n accept_dyn=True)\n while inbound_link.type != 'DYNAMIC':\n path_of_shop.append(inbound_link)\n if inbound_link.src.node.type == 'SAP':\n break\n # The link is STATIC, and its src is not SAP so it is an Infra.\n prev_fr, prev_p = \\\n NFFGToolBox._get_flowrule_and_its_starting_port(\n inbound_link.src.node, fr.id)\n NFFGToolBox._check_flow_consistencity(sg_map, prev_fr)\n inbound_link = NFFGToolBox._find_infra_link(nffg, prev_p,\n outbound=False,\n accept_dyn=True)\n # 'inbound_link' is DYNAMIC here or it is STATIC and starts from\n # a SAP,\n # so the sequence starts here\n sg_map[fr.id][0] = inbound_link.src\n\n # We have to find the ENDING of this flowrule sequence.\n output_port = NFFGToolBox._get_output_port_of_flowrule(i, fr)\n if output_port is None:\n continue\n outbound_link = NFFGToolBox._find_infra_link(nffg, output_port,\n outbound=True,\n accept_dyn=True)\n while outbound_link.type != 'DYNAMIC':\n path_of_shop.append(outbound_link)\n if outbound_link.dst.node.type == 'SAP':\n break\n # The link is STATIC and its dst is not a SAP so it is an Infra.\n next_fr, _ = NFFGToolBox._get_flowrule_and_its_starting_port(\n outbound_link.dst.node, fr.id)\n # '_' is 'outbound_link.dst'\n next_output_port = NFFGToolBox._get_output_port_of_flowrule(\n outbound_link.dst.node, next_fr)\n NFFGToolBox._check_flow_consistencity(sg_map, next_fr)\n outbound_link = NFFGToolBox._find_infra_link(nffg,\n next_output_port,\n outbound=True,\n accept_dyn=True)\n # the 'outbound_link' is DYNAMIC here or finishes in a SAP, so the\n # flowrule sequence finished here.\n sg_map[fr.id][1] = outbound_link.dst\n\n if return_paths:\n sg_map[fr.id].append(path_of_shop)\n\n return sg_map","def sources(self):\n s = [node for node in self.nodes() if node.isSource()]\n s.sort(lambda x,y: cmp(x._id, y._id))\n return s","def run_destination_reduction(self):\n s = self.sources\n t = self.destinations\n\n # get the union set of source edges\n s_edges = [self.out_edges(x) for x in s]\n s_edges_idx = [set(self.get_edges_indices(src)) for src in s_edges]\n S = set.union(*s_edges_idx)\n\n # now starting from the sources\n T_curr = [set(self.in_edges(x)) for x in t]\n T_curr_idx = [set(self.get_edges_indices(x)) for x in T_curr]\n T_union = set.union(*[set(x) for x in T_curr])\n T_union_idx = set.union(*T_curr_idx)\n self.dst_evolution_rec = [T_curr_idx]\n\n while not T_union_idx.issubset(S):\n # get the edges out of the max-ordered node\n tail_nodes = set([x[0] for x in T_union])\n tail_nodes = tail_nodes - set(s)\n v = max(tail_nodes, key=lambda p: self.node[p]['index'])\n\n E = set([edge for edge in T_union if edge[0] == v])\n E_curr = [x.intersection(E) for x in T_curr]\n\n T_next = []\n Uv = self.in_edges(v)\n for (Ex, Tx) in zip(E_curr, T_curr):\n if Ex:\n T_next.append((Tx - Ex).union(Uv))\n else:\n T_next.append(Tx)\n\n T_curr = T_next\n T_curr_idx = [set(self.get_edges_indices(x)) for x in T_curr]\n self.dst_evolution_rec.append(T_curr_idx)\n\n T_union = set.union(*[set(x) for x in T_curr])\n T_union_idx = set.union(*T_curr_idx)","def shortest_flight(self):\r\n distance = sys.maxsize\r\n for code, _list in self.edges.items():\r\n for edge in _list:\r\n if edge.distance < distance:\r\n distance = edge.distance\r\n start = edge.start\r\n destination = edge.destination\r\n return start, destination, distance","def calc_lp(self, demands: Demand, routing: Routing) -> float:\n epsilon = self.epsilon\n\n # Create the linear solver with the GLOP backend.\n solver = pywraplp.Solver('flow_utilisation_lp',\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\n\n ## VARIABLES\n # Flow variables, the amount of flow along each edge\n # stored as a list flow_variables[ith_flow][jth_edge]\n flow_variables = []\n for i in range(len(self.commodities)):\n flow_variable_edges = []\n for j in range(len(self.edges)):\n flow_variable_edges.append(\n solver.NumVar(0, solver.infinity(), '({},{})'.format(i, j)))\n flow_variables.append(flow_variable_edges)\n\n ## CONSTRAINTS\n # Flow from source constraint (net flow must equal demand)\n conservation_source_constraints = []\n for i, commodity in enumerate(self.commodities):\n # create constraint\n constraint_i = solver.Constraint(demands[i] - epsilon,\n demands[i] + epsilon,\n '(source,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[0])]:\n # out flow is positive\n constraint_i.SetCoefficient(flow_variables[i][edge_index], 1)\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[0])]:\n # in flow is negative\n constraint_i.SetCoefficient(flow_variables[i][edge_index], -1)\n conservation_source_constraints.append(constraint_i)\n\n # Flow to sink constraint (in flow must equal demand, out must be zero)\n conservation_sink_constraints = []\n for i, commodity in enumerate(self.commodities):\n # create in flow constraint\n constraint_i_in = solver.Constraint(-demands[i] - epsilon,\n -demands[i] + epsilon,\n '(sink_in,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[1])]:\n # in flow is negative\n constraint_i_in.SetCoefficient(flow_variables[i][edge_index],\n -1)\n conservation_sink_constraints.append(constraint_i_in)\n\n constraint_i_out = solver.Constraint(0, 0,\n '(sink_out,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[1])]:\n # out flow is positive\n constraint_i_out.SetCoefficient(flow_variables[i][edge_index],\n 1)\n conservation_sink_constraints.append(constraint_i_out)\n\n # Flow at transit node constraint (net flow must be zero)\n conservation_transit_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.graph.number_of_nodes()):\n if j != commodity[0] and j != commodity[1]:\n # create constraint\n constraint_j = solver.Constraint(-epsilon, +epsilon,\n '(transit,{},{})'.format(i,\n j))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(j)]:\n # out flow is positive\n constraint_j.SetCoefficient(\n flow_variables[i][edge_index],\n 1)\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(j)]:\n # in flow is negative\n constraint_j.SetCoefficient(\n flow_variables[i][edge_index],\n -1)\n constraints_flow_i.append(constraint_j)\n conservation_transit_constraints.append(constraints_flow_i)\n\n # Flow splitting at transit constraints (edge flow must be correct split of\n # in flow)\n splitting_ratio_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.graph.number_of_nodes()):\n # Sink has not such constraint and we handle source differently\n if j != commodity[1] and j != commodity[0]:\n in_edges = [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(j)]\n out_edges = [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(j)]\n\n # separate constraint for split of each out_edge taking into\n # account all in_edges\n for out_edge_index in out_edges:\n # create constraint\n constraint_edge = \\\n solver.Constraint(-epsilon, +epsilon,\n '(split,{},{},{})'.format(\n i, j,\n out_edge_index))\n split_ratio = routing[i][out_edge_index]\n # flow on out edge\n constraint_edge.SetCoefficient(\n flow_variables[i][out_edge_index], 1)\n for in_edge_index in in_edges:\n # should equal sum of flow on all in edges scaled by\n # split ratio\n constraint_edge.SetCoefficient(\n flow_variables[i][in_edge_index],\n -1 * split_ratio)\n constraints_flow_i.append(constraint_edge)\n splitting_ratio_constraints.append(constraints_flow_i)\n\n # Flow splitting at source constraints (edge flow must be correct split of\n # in flow + demand)\n source_splitting_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n in_edges = [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[0])]\n out_edges = [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[0])]\n for out_edge_index in out_edges:\n # create constraint\n split_ratio = routing[i][out_edge_index]\n split_demand = split_ratio * demands[i]\n constraint_edge = \\\n solver.Constraint(split_demand - epsilon,\n split_demand + epsilon,\n '(split,{},{},{})'.format(i, j,\n out_edge_index))\n # flow on out edge\n constraint_edge.SetCoefficient(\n flow_variables[i][out_edge_index], 1)\n for in_edge_index in in_edges:\n # should equal sum of flow on all in edges scaled by split ratio\n constraint_edge.SetCoefficient(\n flow_variables[i][in_edge_index],\n -1 * split_ratio)\n constraints_flow_i.append(constraint_edge)\n source_splitting_constraints.append(constraints_flow_i)\n\n solver.Solve()\n\n result_status = solver.Solve()\n\n utilisation = np.zeros(\n (len(self.commodities), self.graph.number_of_edges()))\n # # extract the actual routing. Useful for debugging, maybe use to bootstrap\n # assignment = np.zeros(\n # (len(self.commodities), self.graph.number_of_edges()))\n\n # if routing is really that bad, just bail and give a sad result\n if result_status == solver.NOT_SOLVED or result_status == solver.INFEASIBLE:\n return 1.0\n\n for i in range(len(self.commodities)):\n for j in range(self.graph.number_of_edges()):\n utilisation[i][j] = flow_variables[i][j].solution_value() / \\\n self.edges[j][2]['weight']\n # assignment[i][j] = flow_variables[i][j].solution_value()\n\n return np.max(np.sum(utilisation, axis=0))","def dfs(self, starting_vertex, destination_vertex):\n # TODO","def dfs(graph, initial_node, dest_node):\n parents = {}\n dfs_rec(graph, initial_node, {}, parents)\n\n path = []\n current_node = dest_node\n while current_node != initial_node:\n next_node = parents[current_node]\n path = [g.Edge(next_node, current_node, graph.distance(next_node, current_node))] + path\n current_node = next_node\n\n return path","def dfs(self, starting_vertex, destination_vertex):\n # create an empty stack \n stack = Stack()\n #push the starting vertex ID as list\n stack.push([starting_vertex])\n # create an empty Set to store the visited vertices\n visited = set()\n # while the stack is not empty ...\n while stack.size() > 0:\n # pop the first vertex\n path = stack.pop()\n vert = path[-1]\n # if that vertex has not been visited ..\n if vert not in visited:\n #check for target\n if vert == destination_vertex:\n return path\n # mark it is visited\n visited.add(vert)\n # then add all of its neighbors to the top of the stack\n for neighbor in self.vertices[vert]: #self.get_neighbors(vert)\n #copy path to avoid pass by reference\n new_path = list(path) # make a copy\n new_path.append(neighbor)\n stack.push(new_path)","def dft(self, starting_vertex):\n visited = set() # create an empty 'set' to store visisted vertex, set sorts \n\n s = Stack() # create an empty Stack \n s.push(starting_vertex) # push the starting_vertex to the top of the stack\n\n while s.size() > 0: # loop if the size is greater than 0\n v = s.pop() # pop off first element and store \n\n if v not in visited: # if v has not been visited yet\n visited.add(v) # add to the set \n print(v)\n for neighbor in self.vertices[v]: # loop through neighbors \n s.push(neighbor) # add each neighbor to the bottom of the stack","def multipleTravellingSalesmen(self, iterations=None):\n if not iterations:\n iterations = self.mTSPIterations\n\n # Randomly select points drawn from unvisited and distribute equally among the ships\n paths = self.partition(self.unvisited.keys(), len(self.ships))\n [path.append(ship) for path, ship in zip(paths, self.ships)]\n\n # Run single travelling salesman on each of the ships\n paths = [self.singleTravellingSalesman(path, iterations=0) for path in paths]\n\n\n # IF TWO OR MORE SHIPS!!!\n # Point exchange between ships and rerun tsp on each ship\n if len(self.ships) > 1:\n for _ in range(iterations):\n twopathindices = random.sample(xrange(len(paths)), 2)\n newtwopaths = self.swapTwoPointsBetweenPaths([paths[index] for index in twopathindices])\n newtwopaths = [self.singleTravellingSalesman(path, iterations=max(len(path), 100)) for path in\n newtwopaths]\n if self.totalPathDistance(newtwopaths) < self.totalPathDistance(\n [paths[index] for index in twopathindices]):\n for i, index in enumerate(twopathindices):\n paths[index] = newtwopaths[i]\n\n return paths","def hash_flow(flow_5_tuple):\n ip_A = flow_5_tuple[0]\n ip_B = flow_5_tuple[1]\n tp_src = flow_5_tuple[2]\n tp_dst = flow_5_tuple[3]\n proto = flow_5_tuple[4]\n if proto == 6:\n #*** Is a TCP flow:\n if ip_A > ip_B:\n direction = 1\n elif ip_B > ip_A:\n direction = 2\n elif tp_src > tp_dst:\n direction = 1\n elif tp_dst > tp_src:\n direction = 2\n else:\n direction = 1\n else:\n #*** Isn't a flow, so arbitrarily set direction as 1:\n direction = 1\n if direction == 1:\n flow_tuple = (ip_A, ip_B, tp_src, tp_dst, proto)\n else:\n #*** Flip direction:\n flow_tuple = (ip_B, ip_A, tp_dst, tp_src, proto)\n return hash_tuple(flow_tuple)","def shortest_path(graph, source, target):\n return shortest_path_recursive(graph, source, target, set())","def dfs(self, starting_vertex, destination_vertex):\n pass # TODO","def dfs(state):\n\n #if the current state is a goal state, then return it in a list\n if state.is_goal():\n return [state]\n else:\n # else, recurse on the possible next states\n result = []\n \n for s in state.next_states():\n # append all of the s\n result += dfs(s)\n \n return result","def flow_graph_hash(graph):\n assert isinstance(graph, BasicGraph)\n sources = graph.nodes(in_degree=0)\n\n original_hash = 'original hash'\n new_hash = 'new_hash'\n cls = type(graph)\n hash_graph = cls() # new graph with hashes.\n visited = set()\n\n while sources:\n source = sources[0]\n sources = sources[1:]\n\n suppliers = graph.nodes(to_node=source)\n\n hash_func = hashlib.sha3_256()\n hash_func.update(bytes(str(source), 'utf-8'))\n for supplier in suppliers:\n if graph.depth_first_search(start=source, end=supplier):\n continue # it's a cycle.\n d = hash_graph.node(supplier)\n hash_func.update(bytes(d[new_hash], 'utf-8'))\n source_hash = hash_func.hexdigest()\n\n if source not in hash_graph:\n obj = {original_hash: source, new_hash: source_hash}\n hash_graph.add_node(source, obj=obj)\n else:\n n = hash_graph.node(source)\n n[new_hash] = source_hash\n\n receivers = graph.nodes(from_node=source)\n for receiver in receivers:\n if receiver in visited:\n continue\n visited.add(receiver)\n\n if receiver not in hash_graph:\n obj = {original_hash: receiver, new_hash: None}\n hash_graph.add_node(node_id=receiver, obj=obj)\n hash_graph.add_edge(source, receiver)\n if receiver not in sources:\n sources.append(receiver)\n\n for sink in graph.nodes(out_degree=0):\n n = hash_graph.node(sink)\n assert n[new_hash] is not None, n\n\n return hash_graph","def bfs_nodes_generator(graph, source, reverse=...):\n ...","def dfs_paths(graph, start, goal, method='dfs'):\n \n # Define the search method\n stack_pop = -1\n if method == 'bfs':\n stack_pop = 0\n \n stack = [(start, [start])]\n while stack:\n (vertex, path) = stack.pop(stack_pop)\n neighbors = node_neighbors(graph, vertex)\n for next_node in set(neighbors) - set(path):\n if next_node == goal:\n yield path + [next_node]\n else:\n stack.append((next_node, path + [next_node]))","def _get_allow_all_flows() -> List[FlowDescription]:\n return [\n # Set flow match for all packets\n # Don't set the app_name field\n FlowDescription( # uplink flow\n match=FlowMatch(\n direction=FlowMatch.Direction.Value(\"UPLINK\"),\n ),\n action=FlowDescription.Action.Value(\"PERMIT\"),\n ),\n FlowDescription( # downlink flow\n match=FlowMatch(\n direction=FlowMatch.Direction.Value(\"DOWNLINK\"),\n ),\n action=FlowDescription.Action.Value(\"PERMIT\"),\n ),\n ]","def _bfs_nodes(cls, graph, source, size, **kwargs):\n if size < 1:\n return iter(())\n\n return itertools.chain(\n (source,),\n itertools.islice((v for u, v in nx.bfs_edges(graph, source)), size-1)\n )","def get_bfs(self, s):\n # create a queue for BFS\n queue = []\n # mark all the vertices as not visited\n visited = [False] * (len(self.graph))\n # mark the start node as visited and enqueue it\n visited[s] = True\n queue.append(s)\n results = []\n\n while queue:\n # dequeue a vertex from queue and append to results.\n p = queue.pop(0)\n results.append(p)\n # get all adjacent vertices of the dequeued vertex s,\n # and for any unvisited adjacent, mark it visited and enqueue it.\n for v in self.graph[p]:\n if visited[v] is False:\n visited[v] = True\n queue.append(v)\n\n return results","def get_flows(self, x):\n if self.pa_frames == 2:\n flows_backward, flows_forward = self.get_flow_2frames(x)\n elif self.pa_frames == 4:\n flows_backward_2frames, flows_forward_2frames = self.get_flow_2frames(x)\n flows_backward_4frames, flows_forward_4frames = self.get_flow_4frames(flows_forward_2frames, flows_backward_2frames)\n flows_backward = flows_backward_2frames + flows_backward_4frames\n flows_forward = flows_forward_2frames + flows_forward_4frames\n elif self.pa_frames == 6:\n flows_backward_2frames, flows_forward_2frames = self.get_flow_2frames(x)\n flows_backward_4frames, flows_forward_4frames = self.get_flow_4frames(flows_forward_2frames, flows_backward_2frames)\n flows_backward_6frames, flows_forward_6frames = self.get_flow_6frames(flows_forward_2frames, flows_backward_2frames, flows_forward_4frames, flows_backward_4frames)\n flows_backward = flows_backward_2frames + flows_backward_4frames + flows_backward_6frames\n flows_forward = flows_forward_2frames + flows_forward_4frames + flows_forward_6frames\n return flows_backward, flows_forward","def get_weight_from_minflow(self):\n start_nodes = []\n end_nodes = []\n capacities = []\n unit_costs = []\n A = 0\n s_prime = self.sink() + 1\n t_prime = self.sink() + 2\n x = self.sink() + 3\n # for every edge in the graph, add edge to mincost flow instance with\n # infinite capacity and cost 1\n # also add backwards edge\n for arc in self.arc_info.keys():\n # forward edge\n start_nodes.append(self.arc_info[arc][\"start\"])\n end_nodes.append(self.arc_info[arc][\"destin\"])\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"start\"],\n self.arc_info[arc][\"destin\"]))\n # backward edge\n start_nodes.append(self.arc_info[arc][\"destin\"])\n end_nodes.append(self.arc_info[arc][\"start\"])\n capacities.append(int(self.arc_info[arc][\"weight\"])) # no negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"destin\"],\n self.arc_info[arc][\"start\"]))\n # add (x,s) and (t,x) edges with same cap, cost as above\n in_weight_x = 0\n for in_arc in self.in_arcs_lists[self.sink()]:\n in_weight_x += self.arc_info[in_arc][\"weight\"]\n out_weight_x = 0\n for out_arc in self.out_arcs_lists[self.source()]:\n out_weight_x += self.arc_info[out_arc][\"weight\"]\n # (x,s)\n start_nodes.append(x)\n end_nodes.append(self.source())\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.source()))\n # backward\n start_nodes.append(self.source())\n end_nodes.append(x)\n capacities.append(int(out_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.source(),\n x))\n # (t,x)\n start_nodes.append(self.sink())\n end_nodes.append(x)\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.sink(),\n x))\n # backward\n start_nodes.append(x)\n end_nodes.append(self.sink())\n capacities.append(int(in_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.sink()))\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\n # and cost 0.\n for v in self:\n # process internal verts only, since we assume source and sink have\n # no in and out edges respectively\n if v != self.source() and v != self.sink():\n # compute a-exc(v)\n in_weight = 0\n for in_arc in self.in_arcs_lists[v]:\n in_weight += self.arc_info[in_arc][\"weight\"]\n out_weight = 0\n for out_arc in self.out_arcs_lists[v]:\n out_weight += self.arc_info[out_arc][\"weight\"]\n a_exc = out_weight - in_weight\n if a_exc < 0:\n # add edge (s', v)\n start_nodes.append(s_prime)\n end_nodes.append(v)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n v,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (v, t')\n start_nodes.append(v)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n v,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # process x node\n a_exc = out_weight_x - in_weight_x\n if a_exc < 0:\n # add edge (s', x)\n start_nodes.append(s_prime)\n end_nodes.append(x)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n x,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (x, t')\n start_nodes.append(x)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n x,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # we must send flow of A from s_prime to t_prime\n supplies = [0]*(len(self) + 3)\n supplies[s_prime] = int(A)\n supplies[t_prime] = int(-A)\n # Instantiate a SimpleMinCostFlow solver.\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\n # Add each arc.\n for i in range(len(start_nodes)):\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\n end_nodes[i], capacities[i], unit_costs[i])\n # Add node supplies\n for i in range(0, len(supplies)):\n min_cost_flow.SetNodeSupply(i, supplies[i])\n # Find the minimum cost flow between node s' and t'.\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\n print('Minimum cost:', min_cost_flow.OptimalCost())\n print('')\n print(' Arc Flow / Capacity Cost')\n for i in range(min_cost_flow.NumArcs()):\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\n print('%1s -> %1s %3s / %3s %3s' % (\n min_cost_flow.Tail(i),\n min_cost_flow.Head(i),\n min_cost_flow.Flow(i),\n min_cost_flow.Capacity(i),\n cost))\n # update arcs\n start = min_cost_flow.Tail(i)\n destin = min_cost_flow.Head(i)\n if start != s_prime and \\\n start != t_prime and \\\n start != x and \\\n destin != s_prime and \\\n destin != t_prime and \\\n destin != x:\n # if forward, increase flow. otherwise decrease.\n print(\"Processing edge ({}, {})\".format(start, destin))\n if start < destin:\n sup_flow = min_cost_flow.Flow(i)\n else:\n sup_flow = -min_cost_flow.Flow(i)\n temp_start = start\n start = destin\n destin = temp_start\n print(\"Has become ({}, {}) with sup {}\".format(start,\n destin,\n sup_flow))\n arc = self.get_arc(start, destin)\n if (sup_flow != 0) or (\"lower_bound\" not in \\\n self.arc_info[arc].keys()):\n print(\"We should add this\")\n old_flow = self.arc_info[arc][\"weight\"]\n new_flow = old_flow + sup_flow\n self.arc_info[arc][\"weight\"] = int(new_flow)\n print(\"Edge ({},{}) weight is changed from {} to {}\".format(\n start,\n destin,\n old_flow,\n new_flow))\n else:\n print('There was an issue with the min cost flow input.')\n #self.check_conservation_of_flow() # check that solution is valid","def dfs(self, starting_vertex, destination_vertex):\n visited = set()\n paths = [[starting_vertex]]\n \"\"\"\n While the length of possible paths is not zero. \n Store the current path and remove it from possible \n paths. Return the last path if it's the destination. \n If the path hasn't been visited yet add it to the \n visited list and loop over it's edges creating paths \n to check later. \n \"\"\"\n while len(paths) > 0:\n path = paths.pop(-1)\n vertex = path[-1]\n if vertex == destination_vertex:\n return path\n if vertex not in visited:\n visited.add(vertex)\n for key in self.get_neighbors(vertex):\n newPath = path + [key]\n paths.append(newPath)","def shortest_steps(connectors: List[int]):\n connectors = sorted(connectors)\n return [nxt-prv for prv, nxt in zip([0]+connectors, connectors)] + [3]","def _get_staples(self, site, u, links=None):\n if links is None:\n links = self.links\n if len(links.shape) == 1:\n links = tf.reshape(links, self.links.shape)\n\n shape = self.site_idxs\n\n staples = []\n for v in range(self.dim): # u, v instead of mu, nu for readability\n if v != u:\n l1 = self.get_link(site + self.bases[u], v, shape, links)\n l2 = self.get_link(site + self.bases[v], u, shape, links)\n l3 = self.get_link(site, v, shape, links)\n\n l4 = self.get_link(site + self.bases[u] - self.bases[v],\n v, shape, links)\n l5 = self.get_link(site - self.bases[v], u, shape, links)\n l6 = self.get_link(site - self.bases[v], v, shape, links)\n\n if self.link_type == 'U1':\n _sum1 = l1 - l2 - l3\n _sum2 = -l4 -l5 + l6\n\n elif self.link_type in ['SU2', 'SU3']:\n prod1 = tf.matmul(l1, mat_adj(l2))\n prod1 = tf.matmul(prod1, mat_adj(l3))\n\n prod2 = tf.matmul(mat_adj(l3), mat_adj(l4))\n prod2 = tf.matmul(prod2, mat_adj(l6))\n\n _sum = prod1 + prod2\n\n #_arr = [_sum1, _sum2]\n staples.append(_sum1)\n staples.append(_sum2)\n\n return staples","def compute_flow(self, loads):\n assert len(loads) == self.n_nodes\n flow = np.zeros([self.n_nodes, self.n_nodes])\n for k, l in self.lines:\n flow[k, l] = self.line_flow(k, l, loads)\n return flow","def flow_model():\n return {\n 'nodes': [\n {\n 'id': 'left_root',\n 'name': 'left_root',\n 'value': 3.5,\n 'rank': 'l',\n },\n {\n 'id': 'right_root',\n 'name': 'right_root',\n 'value': 3.5,\n 'rank': 'r',\n },\n ], 'edges': [\n {\n 'source': 'left_root',\n 'target': 'right_root',\n 'value': 1.0,\n },\n ]\n }","def get_sources(self, target: Tuple[str, str], relation: str = None) -> List[Node]:\n return self.get_common_sources([target], relation)","def maximum_flow(graph, start, end):\n if not isinstance(graph, BasicGraph):\n raise TypeError(f\"Expected subclass of BasicGraph, not {type(graph)}\")\n Graph = type(graph)\n \n if start not in graph:\n raise ValueError(f\"{start} not in graph\")\n if end not in graph:\n raise ValueError(f\"{end} not in graph\")\n\n inflow = sum(d for s, e, d in graph.edges(from_node=start))\n outflow = sum(d for s, e, d in graph.edges(to_node=end))\n unassigned_flow = min(inflow, outflow) # search in excess of this 'flow' is a waste of time.\n total_flow = 0\n # -----------------------------------------------------------------------\n # The algorithm\n # I reviewed a number of algorithms, such as Ford-fulkerson algorithm,\n # Edmonson-Karp and Dinic, but I didn't like them due to their naive usage\n # of DFS, which leads to a lot of node visits.\n #\n # I therefore choose to invert the capacities of the graph so that the\n # capacity any G[u][v] = c becomes 1/c in G_inverted.\n # This allows me to use the shortest path method to find the path with\n # most capacity in the first attempt, resulting in a significant reduction\n # of unassigned flow.\n #\n # By updating G_inverted, with the residual capacity, I can keep using the\n # shortest path, until the capacity is zero, whereby I remove the links\n # When the shortest path method returns 'No path' or when unassigned flow\n # is zero, I exit the algorithm.\n #\n # Even on small graphs, this method is very efficient, despite the overhead\n # of using shortest path. For very large graphs, this method outperforms\n # all other algorithms by orders of magnitude.\n # -----------------------------------------------------------------------\n\n edges = [(n1, n2, 1 / d) for n1, n2, d in graph.edges() if d > 0]\n inverted_graph = Graph(from_list=edges) # create G_inverted.\n capacity_graph = Graph() # Create structure to record capacity left.\n flow_graph = Graph() # Create structure to record flows.\n\n while unassigned_flow:\n # 1. find the best path\n d, path = shortest_path(inverted_graph, start, end)\n if d == float(\"inf\"): # then there is no path, and we must exit.\n return total_flow, flow_graph\n # else: use the path and lookup the actual flow from the capacity graph.\n\n path_flow = min([min(d, capacity_graph.edge(s, e, default=float(\"inf\"))) for s, e, d in graph.edges(path=path)])\n\n # 2. update the unassigned flow.\n unassigned_flow -= path_flow\n total_flow += path_flow\n\n # 3. record the flows and update the inverted graph, so that it is\n # ready for the next iteration.\n edges = graph.edges(path)\n for n1, n2, d in edges:\n # 3.a. recording:\n v = flow_graph.edge(n1, n2, default=None)\n if v is None:\n flow_graph.add_edge(n1, n2, path_flow)\n c = graph.edge(n1, n2) - path_flow\n else:\n flow_graph.add_edge(n1, n2, value=v + path_flow)\n c = graph.edge(n1, n2) - (v + path_flow)\n capacity_graph.add_edge(n1, n2, c)\n\n # 3.b. updating:\n # if there is capacity left: update with new 1/capacity\n # else: remove node, as we can't do 1/zero.\n if c > 0:\n inverted_graph.add_edge(n1, n2, 1 / c)\n else:\n inverted_graph.del_edge(n1, n2)\n return total_flow, flow_graph","def _dfs(\n self, kg: KG, entity: Vertex, is_reverse: bool = False\n ) -> List[Walk]:\n self.sampler.visited = set()\n walks: List[Walk] = []\n assert self.max_walks is not None\n\n rng = np.random.RandomState(self.random_state)\n\n while len(walks) < self.max_walks:\n sub_walk: Walk = (entity,)\n d = 1\n while d // 2 < self.max_depth:\n pred_obj = self.sampler.sample_hop(\n kg, sub_walk, d // 2 == self.max_depth - 1, is_reverse\n )\n if pred_obj is None:\n break\n\n if is_reverse:\n if (\n pred_obj[0] in self.communities\n and rng.random() < self.hop_prob\n ):\n community_nodes = self.labels_per_community[\n self.communities[pred_obj[0]]\n ]\n sub_walk = (\n pred_obj[1],\n rng.choice(community_nodes),\n ) + sub_walk\n else:\n sub_walk = (pred_obj[1], pred_obj[0]) + sub_walk\n else:\n if (\n pred_obj[1] in self.communities\n and rng.random() < self.hop_prob\n ):\n community_nodes = self.labels_per_community[\n self.communities[pred_obj[1]]\n ]\n sub_walk += (\n pred_obj[0],\n rng.choice(community_nodes),\n )\n else:\n sub_walk += (pred_obj[0], pred_obj[1])\n d = len(sub_walk) - 1\n walks.append(sub_walk)\n return list(walks)","def dfs(self, starting_vertex, destination_vertex):\n \"\"\" LIFO\n Create a stack\n Create a set to store visited\n PUSH starting vertex into an array (STACK)\n While the STACK is NOT empty \n get((pop) first PATH vertex\n get Vertex from END of PATH\n check if NOT visited\n mark as visited\n check if vertex is destination_vertex\n If TRUE, return path \n PUSH path to ALL of neighbors\n make copy of current path\n add neighbor to path copy\n PUSH path copy\n \"\"\" \n s = Stack() # Create a stack\n s.push([starting_vertex]) # PUSH starting vertex into an array (STACK)\n visited = set() # Create a set to store visited\n\n while s.size() > 0: # While the STACK is NOT empty\n path = s.pop() # get(pop) first PATH vertex)\n v = path[-1] # get Vertex from END of PATH \n\n while v not in visited: # check if NOT visited\n visited.add(v) # mark as visited\n\n if v == destination_vertex: # check if vertex is destination_vertex\n return path # If TRUE, return path \n\n for n in self.get_neighbors(v): # PUSH path to ALL of neighbors\n path_c = path[:] # make copy of current path\n # path_c.extend([n]) # add neighbor to path copy\n path_c.append(n) # add neighbor to path copy\n s.push(path_c) # PUSH path copy","def generate_simple_flows(tgen_names, num_bots, bot_msg_size, bot_msg_rate, num_comps, comp_msg_size, comp_msg_rate):\n bot_tgen_ips = [TGEN_IP_PATTERN.format(TGEN_SUBNET_BASE + i) for i in range(num_bots)]\n bot_tgen_ports = [TGEN_PORT_BASE + i for i in range(num_bots)]\n\n # competitor IPs and port numbers start after those assigned to the bots\n comp_tgen_ips = [TGEN_IP_PATTERN.format(TGEN_SUBNET_BASE + i) for i in range(num_bots, num_bots+num_comps)]\n comp_tgen_ports = [TGEN_PORT_BASE + i for i in range(num_bots, num_bots+num_comps)]\n\n # build up flows for bots. Each bot talks to every other bot.\n bot_flows = {}\n for i in range(num_bots):\n bot_flows[i] = {\"flows\": [], \"tgen_name\": tgen_names[i]}\n\n # add a flow for each neighbor bot\n for j in range(len(bot_tgen_ips)):\n # don't add flows to self\n if i != j:\n # send from a unique source port based on the DESTINATION node.\n # use a destination port based on the SOURCE node number\n bot_flows[i][\"flows\"].append({\"src_port\": bot_tgen_ports[j],\n \"dst_ip\": bot_tgen_ips[j],\n \"dst_port\": bot_tgen_ports[i],\n \"msg_rate\": bot_msg_rate,\n \"msg_size\": bot_msg_size,\n })\n\n # build up flows for competitor nodes. Each competitor node talks to every other competitor node.\n comp_flows = {}\n for i in range(num_comps):\n comp_flows[i] = {\"flows\": [], \"tgen_name\": tgen_names[i+num_bots]}\n\n # add a flow for each neighbor bot\n for j in range(len(comp_tgen_ips)):\n # don't add flows to self\n if i != j:\n # send from a unique source port based on the DESTINATION node.\n # use a destination port based on the SOURCE node number\n comp_flows[i][\"flows\"].append({\"src_port\": comp_tgen_ports[j],\n \"dst_ip\": comp_tgen_ips[j],\n \"dst_port\": comp_tgen_ports[i],\n \"msg_rate\": comp_msg_rate,\n \"msg_size\": comp_msg_size,\n })\n\n return bot_flows, comp_flows","def dfs(self):\n def add_to_stack(stack, done, src, path):\n for dest in self.edges[src]:\n if dest not in done:\n for step_path in self.edges[src][dest]:\n stack.append((dest, step_path, path))\n done.add(src)\n stack = [] # Stack of steps to take\n done = set() # Nodes we've visited\n # Seed the stack with all edges from the start cell.\n add_to_stack(stack, done, self.start_cell, '')\n while stack:\n (src, step_path, path) = stack.pop()\n path = path + step_path\n if src == self.exit_cell:\n return path\n add_to_stack(stack, done, src, path)\n return '' # No path found.","def __dynamicThroughput( self, sourceSEs, destSEs ):\n res = self.__getTimeToStart()\n if not res['OK']:\n gLogger.error( res['Message'] )\n return {}\n channelInfo = res['Value']\n\n timeToSite = {} # Maintains time to site including previous hops\n siteAncestor = {} # Maintains the ancestor channel for a site\n tree = {} # Maintains replication tree\n while len( destSEs ) > 0:\n minTotalTimeToStart = float( \"inf\" )\n candidateChannels = []\n sourceActiveSEs = self.__getActiveSEs( sourceSEs )\n for destSE in destSEs:\n destSites = self.__getChannelSitesForSE( destSE )\n localTransfer = False\n for destSite in destSites:\n if localTransfer: break\n for sourceSE in sourceActiveSEs:\n if localTransfer: break\n sourceSites = self.__getChannelSitesForSE( sourceSE )\n for sourceSite in sourceSites:\n if localTransfer: break\n channelName = '%s-%s' % ( sourceSite, destSite )\n if channelInfo.has_key( channelName ):\n channelID = channelInfo[channelName]['ChannelID']\n if tree.has_key( channelID ):\n continue\n channelTimeToStart = channelInfo[channelName]['TimeToStart']\n if timeToSite.has_key( sourceSE ):\n totalTimeToStart = timeToSite[sourceSE] + channelTimeToStart + self.sigma\n else:\n totalTimeToStart = channelTimeToStart\n #print '%s-%s %s %s' % (sourceSE,destSE,channelTimeToStart,totalTimeToStart)\n localTransfer = ( sourceSite == destSite )\n if localTransfer or totalTimeToStart < minTotalTimeToStart:\n minTotalTimeToStart = totalTimeToStart\n selectedPathTimeToStart = totalTimeToStart\n candidateChannels = [( sourceSE, destSE, channelID )]\n elif totalTimeToStart == minTotalTimeToStart:\n candidateChannels.append( ( sourceSE, destSE, channelID ) )\n\n #minTotalTimeToStart = totalTimeToStart\n #selectedPathTimeToStart = totalTimeToStart\n #selectedSourceSE = sourceSE\n #selectedDestSE = destSE\n #selectedChannelID = channelID\n else:\n errStr = 'StrategyHandler.__dynamicThroughput: Channel not defined'\n gLogger.warn( errStr, channelName )\n\n #print 'Selected %s \\n' % selectedPathTimeToStart\n\n random.shuffle( candidateChannels )\n selectedSourceSE, selectedDestSE, selectedChannelID = candidateChannels[0]\n timeToSite[selectedDestSE] = selectedPathTimeToStart\n siteAncestor[selectedDestSE] = selectedChannelID\n\n if siteAncestor.has_key( selectedSourceSE ):\n waitingChannel = siteAncestor[selectedSourceSE]\n else:\n waitingChannel = False\n tree[selectedChannelID] = {}\n tree[selectedChannelID]['Ancestor'] = waitingChannel\n tree[selectedChannelID]['SourceSE'] = selectedSourceSE\n tree[selectedChannelID]['DestSE'] = selectedDestSE\n tree[selectedChannelID]['Strategy'] = 'DynamicThroughput'\n sourceSEs.append( selectedDestSE )\n destSEs.remove( selectedDestSE )\n return tree","def compute_unequal_flow_allocations(target_graph, K=3):\n\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n flow_allocation_seed_number = 0xDEAD_BEEF\n np.random.seed(flow_allocation_seed_number)\n flows = []\n link_utilization = {}\n for node in target_graph.nodes:\n possible_destination_nodes = set(target_graph.nodes) - {node}\n destination_node = np.random.choice(list(possible_destination_nodes), 1, \n replace=False).item()\n shortest_path = nx.shortest_path(target_graph, node, destination_node)\n the_flow = Flow( source_node = node\n , destination_node = destination_node\n , flow_tx_rate = 10.0\n , paths = [shortest_path]\n , splitting_ratio = [1.0]\n )\n flows.append(the_flow)\n\n return flow_allocation_seed_number, flows","def bfs(self, s):\n g = Graph(attr={DIRECTED: True})\n root = self.get_vertex(s)\n root.attributes[DISCOVERED] = True\n q = collections.deque()\n adjacent_type = '+' if DIRECTED in self.attr and self.attr[\n DIRECTED] else None\n # Insert root node in graph and queue\n g.add_vertex(root)\n q.append(s)\n\n while (len(q) > 0):\n v = q.popleft()\n for e in self.get_adjacent_vertices_by_vertex(v, adjacent_type):\n w = self.get_vertex(e)\n if DISCOVERED not in w.attributes or w.attributes[\n DISCOVERED] is False:\n w.attributes[DISCOVERED] = True\n q.append(w.id)\n g.add_vertex(w)\n g.add_edge(edge.Edge(v, e), True)\n return g","def random_one_graph(n):\n return nx.fast_gnp_random_graph(n, 1/(n*n), directed=True)","def main():\n n = int(input(\"Enter the number of nodes: \"))\n m = int(input(\"Enter the number of edges: \"))\n \n adjList = [[] for i in range(n)]\n \n print(\"Enter the edges: \")\n for i in range(m):\n x, y = input().split(\" \")\n x = int(x)\n y = int(y)\n adjList[x].append(y)\n adjList[y].append(x)\n \n s = int(input(\"Enter the source: \"))\n \n DFS(adjList, s, n)","def dfs_r(self, s):\n g = Graph(attr={DIRECTED: True})\n return self.dfs_rec(g, ('#', s))","def dijkstra(self, source=None, destination=None):\n for vertex in self.vertices():\n vertex.d = sys.maxint\n if not source:\n source = self.vertices()[0]\n q = simply_python.data_structures.FIFO_dict()\n source.d = 0\n q.append(source)\n while not q.isempty():\n source = q.pop()\n print source\n print source.d\n d = source.d\n for out_vertex in self.out_vertices(source):\n if out_vertex.d == sys.maxint:\n out_vertex.d = d + 1\n q.append(out_vertex)\n if out_vertex == destination:\n return out_vertex.d\n return d","def shortest_path(self, source, target):\r\n key = self.d.keys()\r\n #check that endpoints are in graph\r\n if source not in key or target not in key:\r\n raise KeyError(str(source) + \" and \" + str(target) + \" must be in graph\")\r\n #initialize V,Q and M\r\n V = []\r\n vis = dict()\r\n Q = deque()\r\n Q.append(source)\r\n M = set(source)\r\n #while target has not been visited\r\n while target not in M:\r\n #take first element of Q\r\n current = Q.popleft()\r\n #add element to visited\r\n V.append(current)\r\n neighbors = self.d[current]\r\n #for each neighbor of element\r\n for n in neighbors:\r\n #if element has not been checked, add it to queue\r\n #also save traveled edge in visited\r\n if n not in M:\r\n Q.append(n)\r\n vis.update({n:current})\r\n M.add(n)\r\n L = [target]\r\n #reverse the order of the traveled edges\r\n while L[-1] in vis.keys():\r\n L.append(vis[L[-1]])\r\n return L[::-1]","def sources(self):\n return [x for x in self if self.in_degree(x)==0]","def gen_task_sets_simplegen(nsets):\n start = time()\n eval_task_sets = []\n for util in utils:\n task_sets = []\n for i in range(nsets):\n ts = synth.simplegen(i, util, implicit_deadlines=True)\n synth.synth_c_pmf(ts, distribution_cls=lib.ExpExceedDist)\n synth.set_fixed_priorities(ts)\n task_sets.append(ts)\n eval_task_sets.append(task_sets)\n stop = time()\n print('Task Set Generation SimpleGen: %.3fs' % (stop - start))\n pickle.dump(eval_task_sets, open(task_sets_path + 'task_sets_simplegen', 'wb'))","def FixedInGraph(N,degrees,replace = True):\n \n conn = np.zeros([N*degrees,2])\n nodes = np.arange(0,N)\n ii = 0\n for i in range(N):\n # for deg in range(degrees):\n source = np.random.choice(nodes,size =degrees,replace=replace)\n conn[ii:ii+len(source),0] = source\n conn[ii:ii+len(source),1] = i\n ii+=len(source) \n return conn","def getDistsSourceToNodes(self):\r\n self.run()\r\n return self.dists_so_far","def _ism_get_mirror_sources(source, receiver, walls, order_threshold, mirrors_threshold):\n logger.info(\"_ism_get_mirror_sources: Determining mirror sources.\")\n model = ism.Model(walls=walls, source=source, receiver=receiver, max_order=order_threshold)\n mirrors = model.determine(strongest=mirrors_threshold)\n yield from mirrors","def shortestPath(graph, start, end, maxOutdistance, toPrint = False):\r\n return DFS(graph, start, end, [], None, sys.maxsize, sys.maxsize, 0, maxOutdistance, toPrint)","def Run(self):\r\n # start all the flows along with updating related flow's transfer time\r\n while self.sched.toStartFlows:\r\n # the first flow is with earliest startTime\r\n curStartFlow = self.sched.toStartFlows[0]\r\n # update flows if there are flows has already finished\r\n while self.sched.runningFlows:\r\n # the first flow is with earliest finishTime\r\n toFinishFlow = self.sched.runningFlows[0]\r\n\r\n if toFinishFlow.finishTime <= curStartFlow.startTime:\r\n # remove this flow from running flows\r\n self.sched.runningFlows.remove(toFinishFlow)\r\n # add this flow to finished flows\r\n self.sched.finishedFlows.append(toFinishFlow)\r\n # Update related flow's transfer time in removing a flow\r\n self.sched.UpdateFlow(toFinishFlow, \"remove\")\r\n # Resort runningFlows by endTime\r\n self.sched.runningFlows.sort(key=lambda x: x.finishTime)\r\n else:\r\n break\r\n # insert current start flow to running list\r\n self.sched.runningFlows.append(curStartFlow)\r\n # Update related flow's transfer time in removing a flow\r\n self.sched.UpdateFlow(curStartFlow, \"insert\")\r\n # Resort runningFlows by endTime\r\n self.sched.runningFlows.sort(key=lambda x: x.finishTime)\r\n # remove this flow from start list\r\n self.sched.toStartFlows.remove(curStartFlow)\r\n\r\n # Now, all the flows are started\r\n # Iteratively update flow's transfer time in running list until all the flows are finished\r\n while self.sched.runningFlows:\r\n # the first flow is always with earliest finish Time\r\n curFinishFlow = self.sched.runningFlows[0]\r\n\r\n # remove it from running list\r\n self.sched.runningFlows.remove(curFinishFlow)\r\n # insert it to finished flows\r\n self.sched.finishedFlows.append(curFinishFlow)\r\n # Update related flow's transfer time in removing a flow\r\n self.sched.UpdateFlow(curFinishFlow, \"remove\")\r\n # Resort runningFlows by endTime\r\n self.sched.runningFlows.sort(key=lambda x: x.finishTime)\r\n\r\n # Finally, all the flows are finished\r\n self.sched.PrintFlows()"],"string":"[\n \"def get_paths_for_flow(F, s, f):\\n links = [((u, v), split_ratio) \\n for (flow_id, u, v), split_ratio in F.items() \\n if flow_id == f and u == s and split_ratio > 0.001]\\n return links\",\n \"def get_paths_for_flow(F, s, f):\\n links = [((u, v), split_ratio) \\n for (flow_id, u, v), split_ratio in F.items() \\n if flow_id == f and u == s and split_ratio > 0.001]\\n return links\",\n \"def compute_path_hopping_flow_allocations(target_graph, K=3):\\n flow_allocation_seed_number = 0xCAFE_BABE\\n np.random.seed(flow_allocation_seed_number)\\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\\n link_utilization = {(u, v): 0.0 for u, v in target_graph.edges}\\n node_capacity = {u: 0.0 for u in target_graph.nodes}\\n flows = []\\n while True:\\n source_node, destination_node = flow_selection_fn(target_graph.nodes, 2, replace=False)\\n print(source_node, destination_node)\\n\\n shortest_paths = sorted(nx.all_simple_paths(target_graph, source_node, destination_node,\\n cutoff=3),\\n key=lambda p: len(p))\\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\\n\\n # flow_tx_rate = np.random.uniform() * 10\\n flow_tx_rate = 1.0\\n # if node_capacity[source_node] + flow_tx_rate > LINK_CAPACITY:\\n # break\\n node_capacity[source_node] += flow_tx_rate\\n capacity_was_exceeded = False \\n for path in [nx.utils.pairwise(p_i) for p_i in k_shortest_paths]:\\n for u, v in [sorted(h_i) for h_i in path]:\\n flow_rate_per_subpath = flow_tx_rate / K\\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\\n capacity_was_exceeded = True\\n break\\n link_utilization[u, v] += flow_rate_per_subpath\\n if capacity_was_exceeded:\\n break\\n\\n if capacity_was_exceeded:\\n break\\n\\n the_flow = Flow( source_node = source_node\\n , destination_node = destination_node\\n , flow_tx_rate = flow_tx_rate\\n , paths = k_shortest_paths\\n , splitting_ratio = [1.0/K]*K\\n )\\n flows.append(the_flow)\\n return flows, link_utilization\",\n \"def test_sources():\\n g = Graph(from_list=[\\n (1, 3, 1),\\n (2, 4, 1),\\n (2, 5, 1),\\n (3, 5, 1),\\n (4, 6, 1),\\n (5, 6, 1),\\n ])\\n g.add_node(7)\\n s = g.sources(5)\\n e = {1, 2, 3}\\n assert s == e\\n\\n s2 = g.sources(1)\\n e2 = set()\\n assert s2 == e2, s2\\n\\n s3 = g.sources(6)\\n e3 = {1, 2, 3, 4, 5}\\n assert s3 == e3\\n\\n s4 = g.sources(7)\\n e4 = set()\\n assert s4 == e4\",\n \"def traverse_graph(F, f, s, t, u, sr):\\n def get_paths_for_flow(F, s, f):\\n \\\"\\\"\\\"\\n RETURNS\\n A set of outgoing links and corresponding splitting ratios for flow f\\n at node s\\n \\\"\\\"\\\"\\n links = [((u, v), split_ratio) \\n for (flow_id, u, v), split_ratio in F.items() \\n if flow_id == f and u == s and split_ratio > 0.001]\\n return links\\n \\n if u == t:\\n return [([t], sr)]\\n\\n outgoing_links = get_paths_for_flow(F, u, f)\\n paths_to_t = []\\n\\n for ((current_node, next_hop), split_ratio) in outgoing_links:\\n paths_from_u_to_t = traverse_graph(F, f, s, t, next_hop, split_ratio) \\n paths_to_t.extend(paths_from_u_to_t)\\n\\n paths_to_t_with_u = []\\n for path in paths_to_t:\\n nodes, sr = path\\n new_path = [u] + nodes\\n paths_to_t_with_u.append((new_path, sr))\\n\\n return paths_to_t_with_u\",\n \"def get_dfs(self, s):\\n results = []\\n # mark all the vertices as not visited\\n visited = [False] * (len(self.graph))\\n self._dfs_recursive(s, visited, results)\\n return results\",\n \"def max_flow(self, source, sink):\\n\\n path = self.valid_path(source, sink, [])\\n\\n while path:\\n # get the maximum possible flow that can be taken from this path:\\n max_flow = min([edge.capacity for edge in path])\\n for edge in path:\\n self.edges[edge] += max_flow\\n path = self.valid_path(source, sink, [])\\n\\n # Compute all the flows from the neighbors of source:\\n return sum([self.edges[edge] for edge in self.adjacents[source]])\",\n \"def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\\n demand: float,\\n routing: np.ndarray) -> np.ndarray:\\n edge_mapping = {edge: i for i, edge in\\n enumerate(sorted(self.graph.edges))}\\n\\n link_utilisation = np.zeros(self.num_edges)\\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\\n node_flow[flow[0]] = demand\\n\\n to_explore = [flow[0]]\\n while to_explore:\\n current_node = to_explore.pop(0)\\n current_flow = node_flow[current_node]\\n\\n # this is the flow destination node so we absorb all flow\\n if current_node == flow[1]:\\n node_flow[current_node] = 0.0\\n continue\\n\\n # push the flow at this node over all edges\\n for edge in self.graph.out_edges(current_node):\\n edge_index = edge_mapping[edge]\\n ratio = routing[edge_index]\\n flow_to_send = ratio * current_flow\\n # only send flow if greater than epsilon (so no 'infinite' loops)\\n if flow_to_send > 1.e-8:\\n node_flow[edge[1]] += ratio * current_flow\\n # all important step, update our output\\n link_utilisation[edge_index] += ratio * current_flow\\n # have updated the dst so add it to the list of things to do\\n to_explore.append(edge[1])\\n # we've moved all the flow from this node now, so reset back to zero\\n node_flow[current_node] = 0.0\\n\\n return link_utilisation\",\n \"def ford_fulkerson_algorithm(graph: np.ndarray, source: int, sink: int) -> np.ndarray:\\r\\n\\r\\n residual_graph = copy.deepcopy(graph)\\r\\n row = len(residual_graph)\\r\\n parent = [-1] * row\\r\\n max_flow = 0\\r\\n\\r\\n if source == sink or sink < 0 or source < 0 or source >= row or sink >= row:\\r\\n raise WrongInputException('Wrong input source/sink vertice(s)')\\r\\n\\r\\n while bfs(residual_graph, row, source, sink, parent):\\r\\n\\r\\n path_flow = float(\\\"Inf\\\")\\r\\n s = sink\\r\\n while s != source:\\r\\n path_flow = min(path_flow, residual_graph[parent[s]][s])\\r\\n s = parent[s]\\r\\n\\r\\n max_flow += path_flow\\r\\n\\r\\n v = sink\\r\\n while v != source:\\r\\n u = parent[v]\\r\\n residual_graph[u][v] -= path_flow\\r\\n residual_graph[v][u] += path_flow\\r\\n v = parent[v]\\r\\n print(\\\"Max flow: %d\\\" % max_flow)\\r\\n\\r\\n return residual_graph\",\n \"def compute_greedy_flow_allocations( target_graph\\n , flow_selection_fn\\n , seed_number=DEFAULT_SEED_NUMBER):\\n\\n flow_allocation_seed_number = seed_number\\n np.random.seed(flow_allocation_seed_number)\\n\\n link_utilization = {tuple(sorted(link_tuple)): 0.0 for link_tuple in target_graph.edges}\\n flows = []\\n\\n while True:\\n capacity_was_exceeded = False\\n\\n source_node, destination_node = flow_selection_fn(target_graph.nodes)\\n flow_tx_rate = np.random.uniform(FLOW_TX_RATE_LOWER_BOUND, FLOW_TX_RATE_UPPER_BOUND)\\n\\n connecting_paths = list(node_disjoint_paths(target_graph, source_node, destination_node))\\n disjoint_path_count = len(connecting_paths)\\n flow_rate_per_subpath = flow_tx_rate / disjoint_path_count\\n for path in [nx.utils.pairwise(p_i) for p_i in connecting_paths]:\\n for u, v in [tuple(sorted(t_i)) for t_i in path]:\\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\\n capacity_was_exceeded = True\\n break\\n link_utilization[u, v] += flow_rate_per_subpath\\n if capacity_was_exceeded:\\n break\\n if capacity_was_exceeded:\\n break\\n\\n the_flow = Flow( source_node = source_node\\n , destination_node = destination_node\\n , flow_tx_rate = flow_tx_rate\\n , paths = connecting_paths\\n , splitting_ratio = [1.0/disjoint_path_count]*disjoint_path_count\\n )\\n flows.append(the_flow)\\n return flows, link_utilization\",\n \"def ListAllFlows(client_id: str) -> List[rdf_flow_objects.Flow]:\\n return data_store.REL_DB.ReadAllFlowObjects(client_id=client_id)\",\n \"def dfs(self, s):\\n g = Graph(attr={DIRECTED: True})\\n adjacent_type = '+' if DIRECTED in self.attr and self.attr[\\n DIRECTED] else None\\n # Insert s root node in stack \\n stack = collections.deque()\\n # Initial node does not have origin, it is represented by # \\n stack.append(('#', s))\\n\\n while (len(stack) > 0):\\n (source, target) = stack.pop()\\n w = self.get_vertex(target)\\n if DISCOVERED not in w.attributes or w.attributes[\\n DISCOVERED] is False:\\n w.attributes[DISCOVERED] = True\\n g.add_vertex(w)\\n if (source != '#'):\\n g.add_edge(edge.Edge(source, w.id), True)\\n for e in self.get_adjacent_vertices_by_vertex(w.id,\\n adjacent_type):\\n stack.append((w.id, e))\\n return g\",\n \"def dijkstra(vs, es, s, stop = None):\\n initialize_single_source(vs, es, s)\\n key = lambda x: -1 * x._ss_d\\n Q = pq(vs)\\n edict = defaultdict(set)\\n for e in es:\\n edict[e.v1].add(e)\\n edict[e.v2].add(e)\\n\\n for i in range(len(vs)):\\n # min path to u is determined at end of loop\\n u = Q.pop()\\n for e in edict[u]:\\n v = e.v1 if e.v1 != u else e.v2\\n relax(u, v, e, Q)\\n if u == stop: return \\n \\n result = [v._ss_d for v in vs]\\n return result\",\n \"def dijkstra(self, s, t):\\n l = []\\n dist = {}\\n prev = {}\\n discovered = {}\\n for v in self.get_vertices():\\n dist[v] = float('inf')\\n prev[v] = None\\n discovered[v] = False\\n dist[s] = 0\\n l.append((s, dist[s]))\\n while len(l) != 0:\\n u = min(l, key=lambda x: x[1])\\n l.remove(u)\\n u = u[0]\\n discovered[u] = True\\n if u == t:\\n break\\n for v in self.get_adjacent_vertices_by_vertex(u):\\n if not discovered[v]:\\n alt = dist[u] + self.get_edge((u, v)).attr[\\\"WEIGHT\\\"]\\n if alt < dist[v]:\\n dist[v] = alt\\n prev[v] = u\\n l.append((v, dist[v]))\\n # Create a graph according to visited nodes store in prev array\\n u = t\\n g = Graph(attr={DIRECTED: True})\\n while u is not None:\\n g.add_vertex(vertex.Vertex(u, {\\\"WEIGHT\\\": dist[u]}))\\n if prev[u] is not None:\\n g.add_vertex(vertex.Vertex(prev[u], {\\\"WEIGHT\\\": dist[prev[u]]}))\\n g.add_edge(edge.Edge(prev[u], u))\\n u = prev[u]\\n else:\\n break\\n return g\",\n \"def dfs_edges_generator(graph, source, reverse=...):\\n ...\",\n \"def set_random_session(self, G, degree_s):\\n sorted_nodes = nx.topological_sort(G)\\n num_nodes = G.number_of_nodes()\\n\\n # create sources and destinations of each of the sections\\n # name the nodes to be the last 4 numbers\\n srcs = [num_nodes, num_nodes + 1]\\n dsts = [num_nodes + 2, num_nodes + 3]\\n\\n end_idx = int(0.3 * len(sorted_nodes))\\n end_idx = max(end_idx, 2)\\n for i in range(2):\\n s = srcs[i]\\n t = dsts[i]\\n reachables = []\\n iter_num = 0\\n\\n while len(reachables) == 0:\\n iter_num += 1\\n if iter_num > 100:\\n end_idx = end_idx * 2\\n\\n # pick an entry point from the first 30%\\n entry_point = random.choice(sorted_nodes[:end_idx])\\n # print \\\"Source \\\", i\\n # print \\\"candidates: \\\", sorted_nodes[:end_idx]\\n # print \\\"entry point: \\\", entry_point\\n # print \\\"all nodes: \\\", G.nodes()\\n\\n # pick a random point from the reachables\\n reachables = nx.shortest_path(G, entry_point)\\n del reachables[entry_point]\\n #print \\\"reachables: \\\", reachables\\n reachables = reachables.keys()\\n\\n exit_point = random.choice(reachables)\\n #print \\\"exit_point: \\\", exit_point\\n\\n if degree_s[i]:\\n G.add_edge(s, entry_point, weight=degree_s[i])\\n G.add_edge(exit_point, t, weight=degree_s[i])\\n else:\\n # figure out the out_degree of entry point\\n out_degree = np.sum(G[u][v]['weight'] for u,v in G.out_edges(entry_point))\\n G.add_edge(s, entry_point, weight=out_degree)\\n\\n # figure out the int_degree of exit point\\n in_degree = np.sum(G[u][v]['weight'] for u,v in G.in_edges(exit_point))\\n G.add_edge(exit_point, t, weight=in_degree)\\n\\n edges = G.edges()\\n for u, v in edges:\\n par_num = int(G[u][v]['weight'])\\n for i in range(par_num):\\n self.add_edge(u, v)\\n\\n # set indices etc\\n self.set_sources(srcs)\\n self.set_destinations(dsts)\\n self.set_indices()\\n #print \\\"number of nodes: \\\" + str(self.number_of_nodes())\\n #print \\\"number of edges: \\\" + str(self.number_of_edges())\",\n \"def sorted_nodes(self):\\r\\n def is_source(node, connections):\\r\\n for connection in connections:\\r\\n if node == connection[1]:\\r\\n return False\\r\\n return True\\r\\n\\r\\n def source_connections(node, connections):\\r\\n conns = set()\\r\\n for connection in connections:\\r\\n if node == connection[0]:\\r\\n conns.add(connection)\\r\\n return conns\\r\\n\\r\\n nodes = set(self.nodes.values())\\r\\n connections = self.connections.copy()\\r\\n sorted_nodes = []\\r\\n\\r\\n # Find source nodes:\\r\\n source_nodes = set([n for n in nodes if is_source(n, connections)])\\r\\n\\r\\n # while S is non-empty do\\r\\n while source_nodes:\\r\\n # remove a node n from S\\r\\n node = source_nodes.pop()\\r\\n # insert n into L\\r\\n sorted_nodes.append(node)\\r\\n\\r\\n # for each node m with an edge e from n to m do\\r\\n s_connections = source_connections(node, connections)\\r\\n for connection in s_connections:\\r\\n # remove edge e from the graph\\r\\n m = connection[1]\\r\\n connections.remove(connection)\\r\\n # if m has no other incoming edges then\\r\\n # insert m into S\\r\\n if is_source(m, connections):\\r\\n source_nodes.add(m)\\r\\n\\r\\n # if graph has edges then\\r\\n # output error message (graph has at least one cycle)\\r\\n # else\\r\\n # output message (proposed topologically sorted order: L)\\r\\n\\r\\n if connections:\\r\\n raise Exception(\\\"Steram has at least one cycle (%d connections left of %d)\\\" % (len(connections), len(self.connections)))\\r\\n\\r\\n return sorted_nodes\",\n \"def find_flows(flows,\\n source_query,\\n target_query,\\n flow_query=None,\\n ignore_edges=None):\\n if flow_query is not None:\\n flows = flows[eval_selection(flows, '', flow_query)]\\n\\n if source_query is None and target_query is None:\\n raise ValueError('source_query and target_query cannot both be None')\\n\\n elif source_query is None and target_query is not None:\\n qt = eval_selection(flows, 'target', target_query)\\n qs = (~eval_selection(flows, 'source', target_query) &\\n ~flows.index.isin(ignore_edges or []))\\n\\n elif source_query is not None and target_query is None:\\n qs = eval_selection(flows, 'source', source_query)\\n qt = (~eval_selection(flows, 'target', source_query) &\\n ~flows.index.isin(ignore_edges or []))\\n\\n else:\\n qs = eval_selection(flows, 'source', source_query)\\n qt = eval_selection(flows, 'target', target_query)\\n\\n f = flows[qs & qt]\\n if source_query is None:\\n internal_source = None\\n else:\\n internal_source = flows[qs & eval_selection(flows, 'target',\\n source_query)]\\n if target_query is None:\\n internal_target = None\\n else:\\n internal_target = flows[qt & eval_selection(flows, 'source',\\n target_query)]\\n\\n return f, internal_source, internal_target\",\n \"def DRBFS(self, flow, edge_mark):\\n\\t\\t# Distance flag for each node\\n\\t\\td = {v:float('inf') for v in self.topo.nodes}\\n\\t\\t# Parent node for each node\\n\\t\\tpa = {v:-1 for v in self.topo.nodes}\\n\\t\\t# Request info\\n\\t\\ts = flow[0]\\n\\t\\tt = flow[1]\\n\\n\\t\\t# BFS to find a min-hop path\\n\\t\\tqueue = [s]; hdr = 0; d[s] = 0\\n\\t\\twhile hdr < len(queue):\\n\\t\\t\\tu = queue[hdr]\\n\\t\\t\\thdr += 1\\n\\n\\t\\t\\tfor v in self.topo.topo.neighbors(u):\\n\\t\\t\\t\\tif edge_mark[(u, v)] or d[v] <= d[u] + 1:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tqueue.append(v)\\n\\t\\t\\t\\td[v] = d[u] + 1\\n\\t\\t\\t\\tpa[v] = u\\n\\t\\t\\t\\tif v == t:\\n\\t\\t\\t\\t\\t# This is because when BFS on edges, the first time reaching t meaning the smallest hop it can be reached\\n\\t\\t\\t\\t\\thdr = len(queue)\\n\\t\\t\\t\\t\\tbreak\\n\\n\\t\\tif d[t] == float('inf'):\\n\\t\\t\\treturn False\\n\\n\\t\\tp = [t]; v = t\\n\\t\\twhile v != s and v != -1:\\n\\t\\t\\tv = pa[v]\\n\\t\\t\\tp.append(v)\\n\\t\\tp.reverse()\\n\\n\\t\\treturn p\",\n \"def objective(graph, flows):\\n\\n G = graph.copy()\\n rules = {}\\n flows.sort(key=lambda a: a[1], reverse=True)\\n\\n for flow,demand in flows:\\n src = get_host_from_ip(G, flow.nw_src)\\n dst = get_host_from_ip(G, flow.nw_dst)\\n\\n if not (src and dst):\\n continue\\n if not (src in G.nodes() and dst in G.nodes()):\\n continue\\n\\n path = widest_path(G, src, dst)\\n\\n hops = []\\n for a,b in pairwise(path):\\n hops.append(Hop(dpid=int(a[1:]), port=G.edge[a][b]['port']))\\n G.edge[a][b]['capacity'] -= demand\\n G.edge[b][a]['capacity'] -= demand\\n\\n rules[flow] = hops\\n\\n return rules\",\n \"def get_routing_solution(self):\\n G = self.base_digraph\\n s1 = self.sources[0]\\n s2 = self.sources[1]\\n t1 = self.destinations[0]\\n t2 = self.destinations[1]\\n\\n try:\\n m = Model('routing')\\n m.setParam('OutputFlag', False)\\n\\n # variables,\\n # We have one variable per edge per session\\n # e is the dict of dict for the variables\\n e = {}\\n r = {}\\n for i in [1,2]:\\n e[i] = {}\\n r[i] = m.addVar()\\n for u,v in G.edges():\\n e[i][u,v] = m.addVar(lb=0)\\n\\n m.update()\\n\\n obj = quicksum(r.values())\\n m.setObjective(obj, GRB.MAXIMIZE)\\n\\n # constraints\\n # 1. conservations of flow at all intermediate nodes\\n # 2. capacity constraints for each edge\\n\\n for u,v in G.edges():\\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\\n\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\\n\\n for n in G.nodes():\\n if n not in [s1, s2, t1, t2]:\\n for i in [1, 2]:\\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\\n m.addConstr(inflow == outflow)\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n for u, v in G.edges():\\n G[u][v]['Routing'] = {}\\n G[u][v]['Routing'][1] = e[1][u,v].x\\n G[u][v]['Routing'][2] = e[2][u,v].x\\n return (m.objVal, r[1].x, r[2].x)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong, no optimal solution obtained\\\"\\n return None, None, None\\n\\n except GurobiError:\\n Print ('Error Report from Gurobi')\",\n \"def make_flow_graph(interaction_logs):\\n G = pgv.AGraph(directed=True)\\n\\n for module_id in interaction_logs['module_id'].unique():\\n G.add_node(module_id)\\n\\n E = defaultdict(set)\\n grouped = interaction_logs.groupby('user_id')\\n for user_id, group in grouped:\\n module_ids_in_student_path = group['module_id']\\n for source_node, target_node in zip(module_ids_in_student_path[:-1], module_ids_in_student_path[1:]):\\n if source_node != target_node: # stationary\\n E[(source_node, target_node)] |= {user_id}\\n\\n for (source_node, target_node), students_that_made_transition in E.iteritems():\\n G.add_edge(\\n source_node,\\n target_node,\\n weight=len(students_that_made_transition))\\n\\n return G\",\n \"def _compute_flows(paths):\\n assert isinstance(paths, list)\\n\\n # allocate memory\\n flows = np.zeros([len(paths), FLAGS.target_height, FLAGS.target_width, 2],\\n dtype=np.float32)\\n\\n # load all images\\n pbar = ProgressBar(max_value=len(paths))\\n for i in range(len(paths)-1):\\n im1 = skimage.io.imread(paths[i])\\n im2 = skimage.io.imread(paths[i+1])\\n\\n im1 = cv2.cvtColor(im1, cv2.COLOR_RGB2GRAY)\\n im2 = cv2.cvtColor(im2, cv2.COLOR_RGB2GRAY)\\n im1 = skimage.transform.resize(\\n im1, [FLAGS.target_height, FLAGS.target_width], preserve_range=True,\\n mode='constant', anti_aliasing=True)\\n im2 = skimage.transform.resize(\\n im2, [FLAGS.target_height, FLAGS.target_width], preserve_range=True,\\n mode='constant', anti_aliasing=True)\\n flow = cv2.calcOpticalFlowFarneback(\\n im1, im2, flow=None, pyr_scale=0.5, levels=3, winsize=15,\\n iterations=3, poly_n=5, poly_sigma=1.2, flags=0)\\n\\n # store images\\n flows[i] = flow\\n pbar.update(i)\\n\\n # Replicate the flow for last frame\\n flows[-1] = flow\\n return flows\",\n \"def step(nodes, outputs, edges):\\n flowed = []\\n for node_name in nodes.copy():\\n if node_name in flowed:\\n continue\\n if len(nodes[node_name]) == 2:\\n if node_name in flowed:\\n continue\\n node = [int(value) for value in nodes[node_name]]\\n low_value, high_value = min(node), max(node)\\n low_flow, high_flow = edges[node_name] \\n low_dictionary, low_node_name = low_flow\\n high_dictionary, high_node_name = high_flow\\n low_node = low_dictionary.get(low_node_name, tuple())\\n high_node = high_dictionary.get(high_node_name, tuple())\\n low_dictionary[low_node_name] = low_node + (str(low_value),)\\n high_dictionary[high_node_name] = high_node + (str(high_value),)\\n nodes[node_name] = tuple()\\n if low_dictionary is nodes:\\n flowed.append(low_node_name)\\n if high_dictionary is nodes:\\n flowed.append(high_node_name)\\n return nodes, outputs, edges\",\n \"def find_all_cycles(s,graph):\\n\\n grph = u.edge_to_list_dict(graph)\\n node_cnt = len(grph)\\n k = z.Int(\\\"k\\\")\\n syms = [z.Int('node%s'%i) for i in range(node_cnt)]\\n\\n # s.add(syms[0] == 0) # start node is a 0\\n s.add(k < node_cnt)\\n s.add(k > 1)\\n\\n o = z.Optimize()\\n\\n # for source, sinks in sgraph.s_adj_list():\\n for i in range(node_cnt):\\n s.add(syms[i] >= 0)\\n s.add(syms[i] <= k)\\n s.add(z.Or([syms[j] == ((syms[i] + 1) % k) for j in grph[i]]) == (syms[i] == 0))\\n\\n\\n r = []\\n m = []\\n\\n # o.minimize(z.Sum([syms[i] for i in range(node_cnt)]))\\n s.add(z.Product([syms[i] for i in range(node_cnt)]) == 0)\\n done = False\\n while not done:\\n if s.check() == z.sat:\\n m = s.model()\\n r.append(m)\\n s.add(k != m[k])\\n else:\\n done = True\\n\\n return r\",\n \"def generateNumsets(G):\\n # paths = []\\n #\\n # path = [0]\\n # for edge in nx.dfs_edges(G, 0):\\n # if edge[0] == path[-1]:\\n # path.append(edge[1])\\n # else:\\n # paths.append(path)\\n # search_index = 2\\n # while search_index <= len(path):\\n # if edge[0] == path[-search_index]:\\n # path = path[:-search_index + 1] + [edge[1]]\\n # break\\n # search_index += 1\\n # else:\\n # raise Exception(\\\"Wrong path structure?\\\", path, edge)\\n # paths.append(path)\\n # return paths\\n\\n \\\"\\\"\\\"\\n Trying to use itertools LMAO\\n \\\"\\\"\\\"\\n # paths = []\\n #\\n # for path in itertools.combinations(G.nodes, 5):\\n # paths.append(path)\\n # return paths\\n\\n \\\"\\\"\\\"\\n Generating paths using graph\\n \\\"\\\"\\\"\\n paths = []\\n n = len(G.nodes)\\n for source in range(n):\\n for target in range(source+1, n):\\n paths.extend([path for path in nx.all_simple_paths(G, source=source, target=target)])\\n return paths\\n\\n # return paths\",\n \"def flowers(self):\\n return self._flowers\",\n \"def possible(self):\\n return [tuple(path) for path in nx.all_shortest_paths(self._gpm.Graph, source=self.source, target=self.target)]\",\n \"def min_path(vs, es, source, target):\\n dijkstra(vs, es, source, stop = target)\\n test = target\\n result = []\\n while test != source:\\n e = test._ss_edge\\n result.append(e)\\n test = e.v1 if e.v1 != test else e.v2\\n assert test == source and test._ss_edge is None\\n return result[::-1]\",\n \"def get_all_pairs(G):\\n # list all (start,dest) pairs between which the route must be computed\\n pairs_list = [(start, dest) for dest in G.nodes for start in G.nodes]\\n\\n # shuffle all elements in-place\\n random.shuffle(pairs_list)\\n\\n # generate a set from the list\\n pairs_set = set(pairs_list)\\n\\n return pairs_list, pairs_set\",\n \"def stochastic_event_set(\\n sources, source_site_filter=filters.source_site_noop_filter):\\n for source, s_sites in source_site_filter(sources):\\n try:\\n for rupture in source.iter_ruptures():\\n for i in range(rupture.sample_number_of_occurrences()):\\n yield rupture\\n except Exception as err:\\n etype, err, tb = sys.exc_info()\\n msg = 'An error occurred with source id=%s. Error: %s'\\n msg %= (source.source_id, str(err))\\n raise_(etype, msg, tb)\",\n \"def _load_flows(paths):\\n assert isinstance(paths, list)\\n # allocate memory\\n flows = np.zeros([len(paths), FLAGS.target_height, FLAGS.target_width, 2],\\n dtype=np.float32)\\n\\n # load all flows\\n pbar = ProgressBar(max_value=len(paths)-1)\\n for i in range(len(paths)):\\n # Load flow\\n flow = np.load(paths[i])\\n\\n # Central crop flow\\n h, w, _ = flow.shape\\n left = (w - FLAGS.target_width) // 2\\n top = (h - FLAGS.target_height) // 2\\n right = left + FLAGS.target_width\\n bottom = top + FLAGS.target_height\\n flow = flow[left:right, top:bottom, :]\\n\\n # Store flow\\n flows[i] = flow\\n pbar.update(i)\\n return flows\",\n \"def showFlow(self):\\r\\n def edgesFromVertex(u):\\r\\n \\\"\\\"\\\"\\r\\n Represents the flow across the given vertex.\\r\\n \\\"\\\"\\\"\\r\\n edgeRepresentation = lambda v: f\\\"({u}, {v}, {self.getCapacity((u, v))}, {self.getFlow((u,v))})\\\"\\r\\n return \\\", \\\".join(map(edgeRepresentation, sorted(self.adjacent[u])))\\r\\n\\r\\n def adjacencyLists():\\r\\n \\\"\\\"\\\"\\r\\n Represents the flow across all relevant vertices.\\r\\n \\\"\\\"\\\"\\r\\n anyNeighbor = lambda u: any(self.neighbors(u))\\r\\n verticesWithNeighbors = filter(anyNeighbor, sorted(self.vertices()))\\r\\n return map(edgesFromVertex, verticesWithNeighbors)\\r\\n\\r\\n return print(\\\"\\\\n\\\".join(adjacencyLists()))\",\n \"def generate_graph(size, number_of_clusters, minimal_size):\\n base_list = list(range(size))\\n result_list = []\\n random.shuffle(base_list)\\n for i in range(number_of_clusters - 1):\\n size = random.randint(minimal_size, len(base_list) - (number_of_clusters - i - 1) * minimal_size)\\n cluster = []\\n for n in range(size):\\n actual = random.choice(base_list)\\n base_list.remove(actual)\\n cluster.append(actual)\\n result_list.append(strongly_connect(cluster))\\n result_list.append(strongly_connect(base_list))\\n\\n while len(result_list) < 5:\\n result_list.append([])\\n\\n print(sorted([len(i) for i in result_list], reverse=True)[:5])\\n\\n return weak_connect_graph(result_list)\",\n \"def __generate_all_shortest_paths(self,cutoff = 10):\\n if cutoff < 1:\\n cutoff = 10\\n self.__logger.info(\\\"cutoff value must be a positive integer. Set back to default value: 10\\\")\\n\\n all_pair_shortest_paths = nx.all_pairs_shortest_path(self.G, cutoff=cutoff)\\n for item in all_pair_shortest_paths:\\n from_node = item[0]\\n paths = item[1]\\n for destination,path in paths.items():\\n yield (len(path),path)\",\n \"def bfs(self, s, visit=None):\\n visited = set()\\n\\n # initialize the queue with the start vertex\\n queue = deque([s])\\n \\n # loop until the queue is empty\\n while queue:\\n\\n # get the next vertex\\n v = queue.popleft()\\n\\n # skip it if it's already visited\\n if v in visited: continue\\n\\n # mark it visited, then invoke the visit function\\n visited.add(v)\\n if visit: visit(v)\\n\\n # add its out vertices to the queue\\n queue.extend(self.out_vertices(v))\\n\\n # return the visited vertices\\n return visited\",\n \"def shortestPath(self, source, target):\\n dist = {}\\n prev = {}\\n q = []\\n for y,a in enumerate(self.sm):\\n for x,b in enumerate(self.sm[y]):\\n dist[(x,y)] = sys.maxint\\n prev[(x,y)] = None\\n q.append((x,y))\\n dist[source] = 0\\n\\n while len(q) is not 0:\\n # find the node with minimum value (u)\\n d = deepcopy(dist)\\n while True:\\n b = dict(map(lambda item: (item[1],item[0]), d.items()))\\n u = b[min(b.keys())]\\n if u not in q:\\n d.pop(u)\\n else:\\n break\\n\\n if dist[u] == sys.maxint: # remaining nodes are inaccessible\\n break\\n\\n q.remove(u)\\n\\n\\n if u == target: # target found\\n break\\n\\n for v in self.getNeighbors(u):\\n alt = dist[u] + 1\\n if alt < dist[v]:\\n dist[v] = alt\\n prev[v] = u\\n\\n s = []\\n u = target\\n while prev[u] is not None:\\n s.append(u)\\n u = prev[u]\\n s.reverse()\\n\\n return s\",\n \"def dijkstra_tree(self, s):\\n l = []\\n dist = {}\\n prev = {}\\n discovered = {}\\n g = Graph(attr={DIRECTED: True})\\n g.add_vertex(vertex.Vertex(s, {\\\"WEIGHT\\\": 0}))\\n for v in self.get_vertices():\\n dist[v] = float('inf')\\n prev[v] = None\\n discovered[v] = False\\n dist[s] = 0\\n l.append((s, dist[s]))\\n while len(l) != 0:\\n u = min(l, key=lambda x: x[1])\\n l.remove(u)\\n u = u[0]\\n discovered[u] = True\\n for v in self.get_adjacent_vertices_by_vertex(u):\\n if not discovered[v]:\\n alt = dist[u] + self.get_edge((u, v)).attr[\\\"WEIGHT\\\"]\\n if alt < dist[v]:\\n dist[v] = alt\\n prev[v] = u\\n l.append((v, dist[v]))\\n g.add_vertex(vertex.Vertex(v, {\\\"WEIGHT\\\": dist[v]}))\\n g.add_edge(edge.Edge(u, v, {\\\"WEIGHT\\\": dist[v]}))\\n\\n return g\",\n \"def bfs (graph, src, tgt):\\n\\n if not graph.has_key(src):\\n raise AttributeError(\\\"The source '%s' is not in the graph\\\" % src)\\n if not graph.has_key(tgt):\\n raise AttributeError(\\\"The target '%s' is not in the graph\\\" % tgt)\\n\\n parents = {src: None}\\n queue = deque([src])\\n while queue:\\n node = queue.popleft()\\n for neighbor in graph[node]:\\n if neighbor not in parents:\\n parents[neighbor] = node\\n queue.append(neighbor)\\n if node == tgt:\\n break\\n\\n path = [tgt]\\n while parents[tgt] is not None:\\n path.insert(0, parents[tgt])\\n tgt = parents[tgt]\\n\\n return path\",\n \"def shortest_route(self, src, dest):\\n\\n # Dijkstra with unusual start condition to prevent src -> src == 0 distance\\n x_in = set()\\n a = defaultdict(lambda: float('inf'))\\n v = self.V.copy()\\n\\n for node, cost in self.G[src].items():\\n a[node] = cost\\n x_in.add(node)\\n v.remove(node)\\n\\n while x_in != self.V:\\n mn = float('inf')\\n new = None\\n for x in x_in:\\n for node, cost in self.G[x].items():\\n if node in v:\\n if (a[x] + cost) < mn: # optimize large/dense G with pri. q\\n mn = a[x] + cost\\n new = (x, node, cost)\\n if new is None:\\n break\\n x, node, cost = new\\n x_in.add(node)\\n v.remove(node)\\n a[node] = a[x] + cost\\n return a[dest]\",\n \"def sens_flow_jsons(contexts: [{}], filter_flow) -> []:\\n jsons = []\\n for context in contexts:\\n context_dir = context['dir']\\n logger.debug(context_dir)\\n for root, dirs, files in os.walk(context_dir):\\n for file in files:\\n if not file.endswith('_sens_http_flows.json'):\\n continue\\n with open(os.path.join(root, file), 'r', encoding=\\\"utf8\\\", errors='ignore') as infile:\\n flows = json.load(infile)\\n for flow in flows:\\n if not filter_flow(flow):\\n # The ground truth label, which is defined by \\\"context\\\" label.\\n flow['real_label'] = context['label']\\n jsons.append(flow)\\n logger.info('The number of flows: %d', len(jsons))\\n return jsons\",\n \"def _pfs_nodes(cls, graph, source, size, priority):\\n if size < 1:\\n return iter(())\\n\\n # use min-heap to implement (max) priority queue\\n # use insertion order to break priority tie\\n queue = []\\n counter = itertools.count()\\n push = lambda priority, node: heappush(queue, (-priority, next(counter), node))\\n pop = partial(heappop, queue)\\n\\n visited = set()\\n enqueued = set()\\n push(priority(source), source)\\n\\n while queue and len(visited) < size:\\n _, _, node = pop()\\n\\n if node in visited:\\n continue\\n\\n visited.add(node)\\n\\n for neighbor in graph[node]:\\n if neighbor not in enqueued:\\n enqueued.add(neighbor)\\n push(priority(neighbor), neighbor)\\n\\n return iter(visited)\",\n \"def get_flow_6frames(self, flows_forward, flows_backward, flows_forward2, flows_backward2):\\n d = flows_forward2[0].shape[1]\\n flows_backward3 = []\\n for flows, flows2 in zip(flows_backward, flows_backward2):\\n flow_list = []\\n for i in range(d - 1, 0, -1):\\n flow_n1 = flows2[:, i - 1, :, :, :]\\n flow_n2 = flows[:, i + 1, :, :, :]\\n flow_list.insert(0, flow_n1 + flow_warp(flow_n2, flow_n1.permute(0, 2, 3, 1)))\\n flows_backward3.append(torch.stack(flow_list, 1))\\n flows_forward3 = []\\n for flows, flows2 in zip(flows_forward, flows_forward2):\\n flow_list = []\\n for i in range(2, d + 1):\\n flow_n1 = flows2[:, i - 1, :, :, :]\\n flow_n2 = flows[:, i - 2, :, :, :]\\n flow_list.append(flow_n1 + flow_warp(flow_n2, flow_n1.permute(0, 2, 3, 1)))\\n flows_forward3.append(torch.stack(flow_list, 1))\\n return flows_backward3, flows_forward3\",\n \"def flows(self, flows):\\n\\n self._flows = flows\",\n \"def get_reachable_nodes(self, source: Node) -> Set[Node]:\\n nodes_found: Set[Node] = {source}\\n queue = [source]\\n while queue:\\n v = queue.pop()\\n for e in v.outgoing_edges:\\n if e.node_to not in nodes_found:\\n nodes_found.add(e.node_to)\\n queue.append(e.node_to)\\n return nodes_found\",\n \"def get_all_network_graphs(list_mtfs):\\n list_graphs = []\\n \\n for mtf in list_mtfs:\\n list_graphs.append(get_network_graph(mtf))\\n \\n return list_graphs\",\n \"def generate(\\n self,\\n num_nodes_src_set: int,\\n num_nodes_dst_set: int,\\n num_edges_src_dst: int,\\n num_edges_dst_src: int,\\n is_directed: bool,\\n return_node_ids: bool = False,\\n transform_graph: bool = True,\\n *args,\\n **kwargs,\\n ):\\n raise NotImplementedError()\",\n \"def get_flows(self, num_flows_per_entry):\\n flows = []\\n for tenant in self._tenants:\\n for contract in tenant.get_children(only_class=Contract):\\n providing_epgs = contract.get_all_providing_epgs()\\n consuming_epgs = contract.get_all_consuming_epgs()\\n for providing_epg in providing_epgs:\\n vlan_ifs = providing_epg.get_all_attached(L2Interface)\\n if len(vlan_ifs):\\n providing_vlan = vlan_ifs[0].encap_id\\n phys_ifs = vlan_ifs[0].get_all_attached(Interface)\\n if len(phys_ifs):\\n providing_phys_if = phys_ifs[0].name\\n for consuming_epg in consuming_epgs:\\n vlan_ifs = consuming_epg.get_all_attached(L2Interface)\\n if len(vlan_ifs):\\n consuming_vlan = vlan_ifs[0].encap_id\\n phys_ifs = vlan_ifs[0].get_all_attached(Interface)\\n if len(phys_ifs):\\n consuming_phys_if = phys_ifs[0].name\\n if providing_vlan == consuming_vlan and providing_phys_if == consuming_phys_if:\\n # Skip this case since traffic would be switched outside fabric\\n continue\\n for filter_entry in contract.get_all_filter_entries():\\n for i in range(0, num_flows_per_entry):\\n flow = Flow()\\n flow.ethertype = filter_entry.etherT\\n if flow.ethertype == 'arp':\\n flow.arp_opcode = filter_entry.arpOpc\\n flow.populate_random_ip_addresses()\\n elif flow.ethertype == 'ip':\\n flow.populate_random_ip_addresses()\\n flow.proto = filter_entry.prot\\n if flow.proto == '6' or flow.proto == '17':\\n dFromPort = int(filter_entry.dFromPort)\\n dToPort = int(filter_entry.dToPort)\\n sFromPort = int(filter_entry.sFromPort)\\n sToPort = int(filter_entry.sToPort)\\n if dFromPort == 0:\\n dFromPort = 1\\n dToPort += 1\\n if sFromPort == 0:\\n sFromPort = 1\\n sToPort += 1\\n if dToPort > 65534:\\n dToPort = 65534\\n if sToPort > 65534:\\n sToPort = 65534\\n flow.dport = str(random_number(dFromPort,\\n dToPort))\\n flow.sport = str(random_number(sFromPort,\\n sToPort))\\n if flow.proto == '6':\\n flow.tcp_rules = filter_entry.tcpRules\\n flow.svlan = providing_vlan\\n flow.dvlan = consuming_vlan\\n flow.src_intf = providing_phys_if\\n flow.dst_intf = consuming_phys_if\\n\\n # Is the flow expected to succeed ?\\n flow.expected_action = 'drop'\\n providing_bd = providing_epg.get_bd()\\n consuming_bd = consuming_epg.get_bd()\\n if providing_bd and consuming_bd:\\n if providing_bd == consuming_bd:\\n if providing_bd.get_context() == consuming_bd.get_context():\\n flow.expected_action = 'permit'\\n flow.populate_random_mac_addresses()\\n flows.append(flow)\\n return flows\",\n \"def ssf(n, N_max = 6, E_max = 4, time_total = 100 ):\\n\\n G = nx.DiGraph()\\n G.add_edge( 0, 1, time_stamp = 1)\\n\\n # List of existing nodes, with nodes repeated once for each adjacent edge\\n repeated_nodes = [0, 1]\\n\\n # compute discrete bins for nodes \\n DistNodes = _get_distribution( N_max, 0 )\\n # compute discrete bins for edges\\n DistLinks = _get_distribution( E_max, 1 )\\n \\n # Start adding the other n - 2 nodes.\\n N_current = time_current = 2\\n while N_current < n and time_current < time_total + 1:\\n # preferential attachment\\n N_current = _preferential_attachment( DistNodes, DistLinks, N_current,\\n time_total, time_current, n, repeated_nodes, G )\\n time_current += 1\\n \\n# print(time_current, N_current)\\n return G\",\n \"def run_dfs(self,s):\\n if self.verbose: print('entering run_dfs with s = ',s)\\n new_states = [self.succ(s,a) for a in self.actions(s)]\\n results = []\\n\\n for ns in new_states:\\n if self.verbose: print('considering new state = ',ns)\\n end = self.is_end(ns)\\n if end:\\n result = self.result(ns)\\n if result is not None:\\n results.append(result)\\n else:\\n results += self.run_dfs(ns)\\n return results\",\n \"def bfs(graph, source):\\n visited = [False] * len(graph.graph)\\n print(visited)\\n\\n result = \\\"\\\"\\n queue = []\\n\\n queue.append(source)\\n visited[source] = True\\n\\n while queue:\\n source = queue.pop(0)\\n result += str(source)\\n\\n while graph.graph[source] is not None:\\n data = graph.graph[source].vertex\\n if not visited[data]:\\n queue.append(data)\\n visited[data] = True\\n graph.graph[source] = graph.graph[source].next\\n return result\",\n \"def compute_shortest_routes(start_ids, dest_ids, G):\\n return ox.distance.shortest_path(G, start_ids, dest_ids, weight='travel_time', cpus=6)\",\n \"def get_all_sghop_info (nffg, return_paths=False):\\n sg_map = {}\\n for i in nffg.infras:\\n for p in i.ports:\\n for fr in p.flowrules:\\n # if fr.external:\\n # continue\\n if fr.id not in sg_map:\\n # The path is unordered!!\\n path_of_shop = []\\n flowclass = NFFGToolBox._extract_flowclass(fr.match.split(\\\";\\\"))\\n sg_map[fr.id] = [None, None, flowclass, fr.bandwidth, fr.delay]\\n # We have to find the BEGINNING of this flowrule sequence.\\n inbound_link = NFFGToolBox._find_infra_link(nffg, p, outbound=False,\\n accept_dyn=True)\\n while inbound_link.type != 'DYNAMIC':\\n path_of_shop.append(inbound_link)\\n if inbound_link.src.node.type == 'SAP':\\n break\\n # The link is STATIC, and its src is not SAP so it is an Infra.\\n prev_fr, prev_p = \\\\\\n NFFGToolBox._get_flowrule_and_its_starting_port(\\n inbound_link.src.node, fr.id)\\n NFFGToolBox._check_flow_consistencity(sg_map, prev_fr)\\n inbound_link = NFFGToolBox._find_infra_link(nffg, prev_p,\\n outbound=False,\\n accept_dyn=True)\\n # 'inbound_link' is DYNAMIC here or it is STATIC and starts from\\n # a SAP,\\n # so the sequence starts here\\n sg_map[fr.id][0] = inbound_link.src\\n\\n # We have to find the ENDING of this flowrule sequence.\\n output_port = NFFGToolBox._get_output_port_of_flowrule(i, fr)\\n if output_port is None:\\n continue\\n outbound_link = NFFGToolBox._find_infra_link(nffg, output_port,\\n outbound=True,\\n accept_dyn=True)\\n while outbound_link.type != 'DYNAMIC':\\n path_of_shop.append(outbound_link)\\n if outbound_link.dst.node.type == 'SAP':\\n break\\n # The link is STATIC and its dst is not a SAP so it is an Infra.\\n next_fr, _ = NFFGToolBox._get_flowrule_and_its_starting_port(\\n outbound_link.dst.node, fr.id)\\n # '_' is 'outbound_link.dst'\\n next_output_port = NFFGToolBox._get_output_port_of_flowrule(\\n outbound_link.dst.node, next_fr)\\n NFFGToolBox._check_flow_consistencity(sg_map, next_fr)\\n outbound_link = NFFGToolBox._find_infra_link(nffg,\\n next_output_port,\\n outbound=True,\\n accept_dyn=True)\\n # the 'outbound_link' is DYNAMIC here or finishes in a SAP, so the\\n # flowrule sequence finished here.\\n sg_map[fr.id][1] = outbound_link.dst\\n\\n if return_paths:\\n sg_map[fr.id].append(path_of_shop)\\n\\n return sg_map\",\n \"def sources(self):\\n s = [node for node in self.nodes() if node.isSource()]\\n s.sort(lambda x,y: cmp(x._id, y._id))\\n return s\",\n \"def run_destination_reduction(self):\\n s = self.sources\\n t = self.destinations\\n\\n # get the union set of source edges\\n s_edges = [self.out_edges(x) for x in s]\\n s_edges_idx = [set(self.get_edges_indices(src)) for src in s_edges]\\n S = set.union(*s_edges_idx)\\n\\n # now starting from the sources\\n T_curr = [set(self.in_edges(x)) for x in t]\\n T_curr_idx = [set(self.get_edges_indices(x)) for x in T_curr]\\n T_union = set.union(*[set(x) for x in T_curr])\\n T_union_idx = set.union(*T_curr_idx)\\n self.dst_evolution_rec = [T_curr_idx]\\n\\n while not T_union_idx.issubset(S):\\n # get the edges out of the max-ordered node\\n tail_nodes = set([x[0] for x in T_union])\\n tail_nodes = tail_nodes - set(s)\\n v = max(tail_nodes, key=lambda p: self.node[p]['index'])\\n\\n E = set([edge for edge in T_union if edge[0] == v])\\n E_curr = [x.intersection(E) for x in T_curr]\\n\\n T_next = []\\n Uv = self.in_edges(v)\\n for (Ex, Tx) in zip(E_curr, T_curr):\\n if Ex:\\n T_next.append((Tx - Ex).union(Uv))\\n else:\\n T_next.append(Tx)\\n\\n T_curr = T_next\\n T_curr_idx = [set(self.get_edges_indices(x)) for x in T_curr]\\n self.dst_evolution_rec.append(T_curr_idx)\\n\\n T_union = set.union(*[set(x) for x in T_curr])\\n T_union_idx = set.union(*T_curr_idx)\",\n \"def shortest_flight(self):\\r\\n distance = sys.maxsize\\r\\n for code, _list in self.edges.items():\\r\\n for edge in _list:\\r\\n if edge.distance < distance:\\r\\n distance = edge.distance\\r\\n start = edge.start\\r\\n destination = edge.destination\\r\\n return start, destination, distance\",\n \"def calc_lp(self, demands: Demand, routing: Routing) -> float:\\n epsilon = self.epsilon\\n\\n # Create the linear solver with the GLOP backend.\\n solver = pywraplp.Solver('flow_utilisation_lp',\\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\\n\\n ## VARIABLES\\n # Flow variables, the amount of flow along each edge\\n # stored as a list flow_variables[ith_flow][jth_edge]\\n flow_variables = []\\n for i in range(len(self.commodities)):\\n flow_variable_edges = []\\n for j in range(len(self.edges)):\\n flow_variable_edges.append(\\n solver.NumVar(0, solver.infinity(), '({},{})'.format(i, j)))\\n flow_variables.append(flow_variable_edges)\\n\\n ## CONSTRAINTS\\n # Flow from source constraint (net flow must equal demand)\\n conservation_source_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # create constraint\\n constraint_i = solver.Constraint(demands[i] - epsilon,\\n demands[i] + epsilon,\\n '(source,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[0])]:\\n # out flow is positive\\n constraint_i.SetCoefficient(flow_variables[i][edge_index], 1)\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[0])]:\\n # in flow is negative\\n constraint_i.SetCoefficient(flow_variables[i][edge_index], -1)\\n conservation_source_constraints.append(constraint_i)\\n\\n # Flow to sink constraint (in flow must equal demand, out must be zero)\\n conservation_sink_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # create in flow constraint\\n constraint_i_in = solver.Constraint(-demands[i] - epsilon,\\n -demands[i] + epsilon,\\n '(sink_in,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[1])]:\\n # in flow is negative\\n constraint_i_in.SetCoefficient(flow_variables[i][edge_index],\\n -1)\\n conservation_sink_constraints.append(constraint_i_in)\\n\\n constraint_i_out = solver.Constraint(0, 0,\\n '(sink_out,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[1])]:\\n # out flow is positive\\n constraint_i_out.SetCoefficient(flow_variables[i][edge_index],\\n 1)\\n conservation_sink_constraints.append(constraint_i_out)\\n\\n # Flow at transit node constraint (net flow must be zero)\\n conservation_transit_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.graph.number_of_nodes()):\\n if j != commodity[0] and j != commodity[1]:\\n # create constraint\\n constraint_j = solver.Constraint(-epsilon, +epsilon,\\n '(transit,{},{})'.format(i,\\n j))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(j)]:\\n # out flow is positive\\n constraint_j.SetCoefficient(\\n flow_variables[i][edge_index],\\n 1)\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(j)]:\\n # in flow is negative\\n constraint_j.SetCoefficient(\\n flow_variables[i][edge_index],\\n -1)\\n constraints_flow_i.append(constraint_j)\\n conservation_transit_constraints.append(constraints_flow_i)\\n\\n # Flow splitting at transit constraints (edge flow must be correct split of\\n # in flow)\\n splitting_ratio_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.graph.number_of_nodes()):\\n # Sink has not such constraint and we handle source differently\\n if j != commodity[1] and j != commodity[0]:\\n in_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(j)]\\n out_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(j)]\\n\\n # separate constraint for split of each out_edge taking into\\n # account all in_edges\\n for out_edge_index in out_edges:\\n # create constraint\\n constraint_edge = \\\\\\n solver.Constraint(-epsilon, +epsilon,\\n '(split,{},{},{})'.format(\\n i, j,\\n out_edge_index))\\n split_ratio = routing[i][out_edge_index]\\n # flow on out edge\\n constraint_edge.SetCoefficient(\\n flow_variables[i][out_edge_index], 1)\\n for in_edge_index in in_edges:\\n # should equal sum of flow on all in edges scaled by\\n # split ratio\\n constraint_edge.SetCoefficient(\\n flow_variables[i][in_edge_index],\\n -1 * split_ratio)\\n constraints_flow_i.append(constraint_edge)\\n splitting_ratio_constraints.append(constraints_flow_i)\\n\\n # Flow splitting at source constraints (edge flow must be correct split of\\n # in flow + demand)\\n source_splitting_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n in_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[0])]\\n out_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[0])]\\n for out_edge_index in out_edges:\\n # create constraint\\n split_ratio = routing[i][out_edge_index]\\n split_demand = split_ratio * demands[i]\\n constraint_edge = \\\\\\n solver.Constraint(split_demand - epsilon,\\n split_demand + epsilon,\\n '(split,{},{},{})'.format(i, j,\\n out_edge_index))\\n # flow on out edge\\n constraint_edge.SetCoefficient(\\n flow_variables[i][out_edge_index], 1)\\n for in_edge_index in in_edges:\\n # should equal sum of flow on all in edges scaled by split ratio\\n constraint_edge.SetCoefficient(\\n flow_variables[i][in_edge_index],\\n -1 * split_ratio)\\n constraints_flow_i.append(constraint_edge)\\n source_splitting_constraints.append(constraints_flow_i)\\n\\n solver.Solve()\\n\\n result_status = solver.Solve()\\n\\n utilisation = np.zeros(\\n (len(self.commodities), self.graph.number_of_edges()))\\n # # extract the actual routing. Useful for debugging, maybe use to bootstrap\\n # assignment = np.zeros(\\n # (len(self.commodities), self.graph.number_of_edges()))\\n\\n # if routing is really that bad, just bail and give a sad result\\n if result_status == solver.NOT_SOLVED or result_status == solver.INFEASIBLE:\\n return 1.0\\n\\n for i in range(len(self.commodities)):\\n for j in range(self.graph.number_of_edges()):\\n utilisation[i][j] = flow_variables[i][j].solution_value() / \\\\\\n self.edges[j][2]['weight']\\n # assignment[i][j] = flow_variables[i][j].solution_value()\\n\\n return np.max(np.sum(utilisation, axis=0))\",\n \"def dfs(self, starting_vertex, destination_vertex):\\n # TODO\",\n \"def dfs(graph, initial_node, dest_node):\\n parents = {}\\n dfs_rec(graph, initial_node, {}, parents)\\n\\n path = []\\n current_node = dest_node\\n while current_node != initial_node:\\n next_node = parents[current_node]\\n path = [g.Edge(next_node, current_node, graph.distance(next_node, current_node))] + path\\n current_node = next_node\\n\\n return path\",\n \"def dfs(self, starting_vertex, destination_vertex):\\n # create an empty stack \\n stack = Stack()\\n #push the starting vertex ID as list\\n stack.push([starting_vertex])\\n # create an empty Set to store the visited vertices\\n visited = set()\\n # while the stack is not empty ...\\n while stack.size() > 0:\\n # pop the first vertex\\n path = stack.pop()\\n vert = path[-1]\\n # if that vertex has not been visited ..\\n if vert not in visited:\\n #check for target\\n if vert == destination_vertex:\\n return path\\n # mark it is visited\\n visited.add(vert)\\n # then add all of its neighbors to the top of the stack\\n for neighbor in self.vertices[vert]: #self.get_neighbors(vert)\\n #copy path to avoid pass by reference\\n new_path = list(path) # make a copy\\n new_path.append(neighbor)\\n stack.push(new_path)\",\n \"def dft(self, starting_vertex):\\n visited = set() # create an empty 'set' to store visisted vertex, set sorts \\n\\n s = Stack() # create an empty Stack \\n s.push(starting_vertex) # push the starting_vertex to the top of the stack\\n\\n while s.size() > 0: # loop if the size is greater than 0\\n v = s.pop() # pop off first element and store \\n\\n if v not in visited: # if v has not been visited yet\\n visited.add(v) # add to the set \\n print(v)\\n for neighbor in self.vertices[v]: # loop through neighbors \\n s.push(neighbor) # add each neighbor to the bottom of the stack\",\n \"def multipleTravellingSalesmen(self, iterations=None):\\n if not iterations:\\n iterations = self.mTSPIterations\\n\\n # Randomly select points drawn from unvisited and distribute equally among the ships\\n paths = self.partition(self.unvisited.keys(), len(self.ships))\\n [path.append(ship) for path, ship in zip(paths, self.ships)]\\n\\n # Run single travelling salesman on each of the ships\\n paths = [self.singleTravellingSalesman(path, iterations=0) for path in paths]\\n\\n\\n # IF TWO OR MORE SHIPS!!!\\n # Point exchange between ships and rerun tsp on each ship\\n if len(self.ships) > 1:\\n for _ in range(iterations):\\n twopathindices = random.sample(xrange(len(paths)), 2)\\n newtwopaths = self.swapTwoPointsBetweenPaths([paths[index] for index in twopathindices])\\n newtwopaths = [self.singleTravellingSalesman(path, iterations=max(len(path), 100)) for path in\\n newtwopaths]\\n if self.totalPathDistance(newtwopaths) < self.totalPathDistance(\\n [paths[index] for index in twopathindices]):\\n for i, index in enumerate(twopathindices):\\n paths[index] = newtwopaths[i]\\n\\n return paths\",\n \"def hash_flow(flow_5_tuple):\\n ip_A = flow_5_tuple[0]\\n ip_B = flow_5_tuple[1]\\n tp_src = flow_5_tuple[2]\\n tp_dst = flow_5_tuple[3]\\n proto = flow_5_tuple[4]\\n if proto == 6:\\n #*** Is a TCP flow:\\n if ip_A > ip_B:\\n direction = 1\\n elif ip_B > ip_A:\\n direction = 2\\n elif tp_src > tp_dst:\\n direction = 1\\n elif tp_dst > tp_src:\\n direction = 2\\n else:\\n direction = 1\\n else:\\n #*** Isn't a flow, so arbitrarily set direction as 1:\\n direction = 1\\n if direction == 1:\\n flow_tuple = (ip_A, ip_B, tp_src, tp_dst, proto)\\n else:\\n #*** Flip direction:\\n flow_tuple = (ip_B, ip_A, tp_dst, tp_src, proto)\\n return hash_tuple(flow_tuple)\",\n \"def shortest_path(graph, source, target):\\n return shortest_path_recursive(graph, source, target, set())\",\n \"def dfs(self, starting_vertex, destination_vertex):\\n pass # TODO\",\n \"def dfs(state):\\n\\n #if the current state is a goal state, then return it in a list\\n if state.is_goal():\\n return [state]\\n else:\\n # else, recurse on the possible next states\\n result = []\\n \\n for s in state.next_states():\\n # append all of the s\\n result += dfs(s)\\n \\n return result\",\n \"def flow_graph_hash(graph):\\n assert isinstance(graph, BasicGraph)\\n sources = graph.nodes(in_degree=0)\\n\\n original_hash = 'original hash'\\n new_hash = 'new_hash'\\n cls = type(graph)\\n hash_graph = cls() # new graph with hashes.\\n visited = set()\\n\\n while sources:\\n source = sources[0]\\n sources = sources[1:]\\n\\n suppliers = graph.nodes(to_node=source)\\n\\n hash_func = hashlib.sha3_256()\\n hash_func.update(bytes(str(source), 'utf-8'))\\n for supplier in suppliers:\\n if graph.depth_first_search(start=source, end=supplier):\\n continue # it's a cycle.\\n d = hash_graph.node(supplier)\\n hash_func.update(bytes(d[new_hash], 'utf-8'))\\n source_hash = hash_func.hexdigest()\\n\\n if source not in hash_graph:\\n obj = {original_hash: source, new_hash: source_hash}\\n hash_graph.add_node(source, obj=obj)\\n else:\\n n = hash_graph.node(source)\\n n[new_hash] = source_hash\\n\\n receivers = graph.nodes(from_node=source)\\n for receiver in receivers:\\n if receiver in visited:\\n continue\\n visited.add(receiver)\\n\\n if receiver not in hash_graph:\\n obj = {original_hash: receiver, new_hash: None}\\n hash_graph.add_node(node_id=receiver, obj=obj)\\n hash_graph.add_edge(source, receiver)\\n if receiver not in sources:\\n sources.append(receiver)\\n\\n for sink in graph.nodes(out_degree=0):\\n n = hash_graph.node(sink)\\n assert n[new_hash] is not None, n\\n\\n return hash_graph\",\n \"def bfs_nodes_generator(graph, source, reverse=...):\\n ...\",\n \"def dfs_paths(graph, start, goal, method='dfs'):\\n \\n # Define the search method\\n stack_pop = -1\\n if method == 'bfs':\\n stack_pop = 0\\n \\n stack = [(start, [start])]\\n while stack:\\n (vertex, path) = stack.pop(stack_pop)\\n neighbors = node_neighbors(graph, vertex)\\n for next_node in set(neighbors) - set(path):\\n if next_node == goal:\\n yield path + [next_node]\\n else:\\n stack.append((next_node, path + [next_node]))\",\n \"def _get_allow_all_flows() -> List[FlowDescription]:\\n return [\\n # Set flow match for all packets\\n # Don't set the app_name field\\n FlowDescription( # uplink flow\\n match=FlowMatch(\\n direction=FlowMatch.Direction.Value(\\\"UPLINK\\\"),\\n ),\\n action=FlowDescription.Action.Value(\\\"PERMIT\\\"),\\n ),\\n FlowDescription( # downlink flow\\n match=FlowMatch(\\n direction=FlowMatch.Direction.Value(\\\"DOWNLINK\\\"),\\n ),\\n action=FlowDescription.Action.Value(\\\"PERMIT\\\"),\\n ),\\n ]\",\n \"def _bfs_nodes(cls, graph, source, size, **kwargs):\\n if size < 1:\\n return iter(())\\n\\n return itertools.chain(\\n (source,),\\n itertools.islice((v for u, v in nx.bfs_edges(graph, source)), size-1)\\n )\",\n \"def get_bfs(self, s):\\n # create a queue for BFS\\n queue = []\\n # mark all the vertices as not visited\\n visited = [False] * (len(self.graph))\\n # mark the start node as visited and enqueue it\\n visited[s] = True\\n queue.append(s)\\n results = []\\n\\n while queue:\\n # dequeue a vertex from queue and append to results.\\n p = queue.pop(0)\\n results.append(p)\\n # get all adjacent vertices of the dequeued vertex s,\\n # and for any unvisited adjacent, mark it visited and enqueue it.\\n for v in self.graph[p]:\\n if visited[v] is False:\\n visited[v] = True\\n queue.append(v)\\n\\n return results\",\n \"def get_flows(self, x):\\n if self.pa_frames == 2:\\n flows_backward, flows_forward = self.get_flow_2frames(x)\\n elif self.pa_frames == 4:\\n flows_backward_2frames, flows_forward_2frames = self.get_flow_2frames(x)\\n flows_backward_4frames, flows_forward_4frames = self.get_flow_4frames(flows_forward_2frames, flows_backward_2frames)\\n flows_backward = flows_backward_2frames + flows_backward_4frames\\n flows_forward = flows_forward_2frames + flows_forward_4frames\\n elif self.pa_frames == 6:\\n flows_backward_2frames, flows_forward_2frames = self.get_flow_2frames(x)\\n flows_backward_4frames, flows_forward_4frames = self.get_flow_4frames(flows_forward_2frames, flows_backward_2frames)\\n flows_backward_6frames, flows_forward_6frames = self.get_flow_6frames(flows_forward_2frames, flows_backward_2frames, flows_forward_4frames, flows_backward_4frames)\\n flows_backward = flows_backward_2frames + flows_backward_4frames + flows_backward_6frames\\n flows_forward = flows_forward_2frames + flows_forward_4frames + flows_forward_6frames\\n return flows_backward, flows_forward\",\n \"def get_weight_from_minflow(self):\\n start_nodes = []\\n end_nodes = []\\n capacities = []\\n unit_costs = []\\n A = 0\\n s_prime = self.sink() + 1\\n t_prime = self.sink() + 2\\n x = self.sink() + 3\\n # for every edge in the graph, add edge to mincost flow instance with\\n # infinite capacity and cost 1\\n # also add backwards edge\\n for arc in self.arc_info.keys():\\n # forward edge\\n start_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"start\\\"],\\n self.arc_info[arc][\\\"destin\\\"]))\\n # backward edge\\n start_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n capacities.append(int(self.arc_info[arc][\\\"weight\\\"])) # no negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"destin\\\"],\\n self.arc_info[arc][\\\"start\\\"]))\\n # add (x,s) and (t,x) edges with same cap, cost as above\\n in_weight_x = 0\\n for in_arc in self.in_arcs_lists[self.sink()]:\\n in_weight_x += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight_x = 0\\n for out_arc in self.out_arcs_lists[self.source()]:\\n out_weight_x += self.arc_info[out_arc][\\\"weight\\\"]\\n # (x,s)\\n start_nodes.append(x)\\n end_nodes.append(self.source())\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.source()))\\n # backward\\n start_nodes.append(self.source())\\n end_nodes.append(x)\\n capacities.append(int(out_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.source(),\\n x))\\n # (t,x)\\n start_nodes.append(self.sink())\\n end_nodes.append(x)\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.sink(),\\n x))\\n # backward\\n start_nodes.append(x)\\n end_nodes.append(self.sink())\\n capacities.append(int(in_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.sink()))\\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\\n # and cost 0.\\n for v in self:\\n # process internal verts only, since we assume source and sink have\\n # no in and out edges respectively\\n if v != self.source() and v != self.sink():\\n # compute a-exc(v)\\n in_weight = 0\\n for in_arc in self.in_arcs_lists[v]:\\n in_weight += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight = 0\\n for out_arc in self.out_arcs_lists[v]:\\n out_weight += self.arc_info[out_arc][\\\"weight\\\"]\\n a_exc = out_weight - in_weight\\n if a_exc < 0:\\n # add edge (s', v)\\n start_nodes.append(s_prime)\\n end_nodes.append(v)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n v,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (v, t')\\n start_nodes.append(v)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n v,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # process x node\\n a_exc = out_weight_x - in_weight_x\\n if a_exc < 0:\\n # add edge (s', x)\\n start_nodes.append(s_prime)\\n end_nodes.append(x)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n x,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (x, t')\\n start_nodes.append(x)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n x,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # we must send flow of A from s_prime to t_prime\\n supplies = [0]*(len(self) + 3)\\n supplies[s_prime] = int(A)\\n supplies[t_prime] = int(-A)\\n # Instantiate a SimpleMinCostFlow solver.\\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\\n # Add each arc.\\n for i in range(len(start_nodes)):\\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\\n end_nodes[i], capacities[i], unit_costs[i])\\n # Add node supplies\\n for i in range(0, len(supplies)):\\n min_cost_flow.SetNodeSupply(i, supplies[i])\\n # Find the minimum cost flow between node s' and t'.\\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\\n print('Minimum cost:', min_cost_flow.OptimalCost())\\n print('')\\n print(' Arc Flow / Capacity Cost')\\n for i in range(min_cost_flow.NumArcs()):\\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\\n print('%1s -> %1s %3s / %3s %3s' % (\\n min_cost_flow.Tail(i),\\n min_cost_flow.Head(i),\\n min_cost_flow.Flow(i),\\n min_cost_flow.Capacity(i),\\n cost))\\n # update arcs\\n start = min_cost_flow.Tail(i)\\n destin = min_cost_flow.Head(i)\\n if start != s_prime and \\\\\\n start != t_prime and \\\\\\n start != x and \\\\\\n destin != s_prime and \\\\\\n destin != t_prime and \\\\\\n destin != x:\\n # if forward, increase flow. otherwise decrease.\\n print(\\\"Processing edge ({}, {})\\\".format(start, destin))\\n if start < destin:\\n sup_flow = min_cost_flow.Flow(i)\\n else:\\n sup_flow = -min_cost_flow.Flow(i)\\n temp_start = start\\n start = destin\\n destin = temp_start\\n print(\\\"Has become ({}, {}) with sup {}\\\".format(start,\\n destin,\\n sup_flow))\\n arc = self.get_arc(start, destin)\\n if (sup_flow != 0) or (\\\"lower_bound\\\" not in \\\\\\n self.arc_info[arc].keys()):\\n print(\\\"We should add this\\\")\\n old_flow = self.arc_info[arc][\\\"weight\\\"]\\n new_flow = old_flow + sup_flow\\n self.arc_info[arc][\\\"weight\\\"] = int(new_flow)\\n print(\\\"Edge ({},{}) weight is changed from {} to {}\\\".format(\\n start,\\n destin,\\n old_flow,\\n new_flow))\\n else:\\n print('There was an issue with the min cost flow input.')\\n #self.check_conservation_of_flow() # check that solution is valid\",\n \"def dfs(self, starting_vertex, destination_vertex):\\n visited = set()\\n paths = [[starting_vertex]]\\n \\\"\\\"\\\"\\n While the length of possible paths is not zero. \\n Store the current path and remove it from possible \\n paths. Return the last path if it's the destination. \\n If the path hasn't been visited yet add it to the \\n visited list and loop over it's edges creating paths \\n to check later. \\n \\\"\\\"\\\"\\n while len(paths) > 0:\\n path = paths.pop(-1)\\n vertex = path[-1]\\n if vertex == destination_vertex:\\n return path\\n if vertex not in visited:\\n visited.add(vertex)\\n for key in self.get_neighbors(vertex):\\n newPath = path + [key]\\n paths.append(newPath)\",\n \"def shortest_steps(connectors: List[int]):\\n connectors = sorted(connectors)\\n return [nxt-prv for prv, nxt in zip([0]+connectors, connectors)] + [3]\",\n \"def _get_staples(self, site, u, links=None):\\n if links is None:\\n links = self.links\\n if len(links.shape) == 1:\\n links = tf.reshape(links, self.links.shape)\\n\\n shape = self.site_idxs\\n\\n staples = []\\n for v in range(self.dim): # u, v instead of mu, nu for readability\\n if v != u:\\n l1 = self.get_link(site + self.bases[u], v, shape, links)\\n l2 = self.get_link(site + self.bases[v], u, shape, links)\\n l3 = self.get_link(site, v, shape, links)\\n\\n l4 = self.get_link(site + self.bases[u] - self.bases[v],\\n v, shape, links)\\n l5 = self.get_link(site - self.bases[v], u, shape, links)\\n l6 = self.get_link(site - self.bases[v], v, shape, links)\\n\\n if self.link_type == 'U1':\\n _sum1 = l1 - l2 - l3\\n _sum2 = -l4 -l5 + l6\\n\\n elif self.link_type in ['SU2', 'SU3']:\\n prod1 = tf.matmul(l1, mat_adj(l2))\\n prod1 = tf.matmul(prod1, mat_adj(l3))\\n\\n prod2 = tf.matmul(mat_adj(l3), mat_adj(l4))\\n prod2 = tf.matmul(prod2, mat_adj(l6))\\n\\n _sum = prod1 + prod2\\n\\n #_arr = [_sum1, _sum2]\\n staples.append(_sum1)\\n staples.append(_sum2)\\n\\n return staples\",\n \"def compute_flow(self, loads):\\n assert len(loads) == self.n_nodes\\n flow = np.zeros([self.n_nodes, self.n_nodes])\\n for k, l in self.lines:\\n flow[k, l] = self.line_flow(k, l, loads)\\n return flow\",\n \"def flow_model():\\n return {\\n 'nodes': [\\n {\\n 'id': 'left_root',\\n 'name': 'left_root',\\n 'value': 3.5,\\n 'rank': 'l',\\n },\\n {\\n 'id': 'right_root',\\n 'name': 'right_root',\\n 'value': 3.5,\\n 'rank': 'r',\\n },\\n ], 'edges': [\\n {\\n 'source': 'left_root',\\n 'target': 'right_root',\\n 'value': 1.0,\\n },\\n ]\\n }\",\n \"def get_sources(self, target: Tuple[str, str], relation: str = None) -> List[Node]:\\n return self.get_common_sources([target], relation)\",\n \"def maximum_flow(graph, start, end):\\n if not isinstance(graph, BasicGraph):\\n raise TypeError(f\\\"Expected subclass of BasicGraph, not {type(graph)}\\\")\\n Graph = type(graph)\\n \\n if start not in graph:\\n raise ValueError(f\\\"{start} not in graph\\\")\\n if end not in graph:\\n raise ValueError(f\\\"{end} not in graph\\\")\\n\\n inflow = sum(d for s, e, d in graph.edges(from_node=start))\\n outflow = sum(d for s, e, d in graph.edges(to_node=end))\\n unassigned_flow = min(inflow, outflow) # search in excess of this 'flow' is a waste of time.\\n total_flow = 0\\n # -----------------------------------------------------------------------\\n # The algorithm\\n # I reviewed a number of algorithms, such as Ford-fulkerson algorithm,\\n # Edmonson-Karp and Dinic, but I didn't like them due to their naive usage\\n # of DFS, which leads to a lot of node visits.\\n #\\n # I therefore choose to invert the capacities of the graph so that the\\n # capacity any G[u][v] = c becomes 1/c in G_inverted.\\n # This allows me to use the shortest path method to find the path with\\n # most capacity in the first attempt, resulting in a significant reduction\\n # of unassigned flow.\\n #\\n # By updating G_inverted, with the residual capacity, I can keep using the\\n # shortest path, until the capacity is zero, whereby I remove the links\\n # When the shortest path method returns 'No path' or when unassigned flow\\n # is zero, I exit the algorithm.\\n #\\n # Even on small graphs, this method is very efficient, despite the overhead\\n # of using shortest path. For very large graphs, this method outperforms\\n # all other algorithms by orders of magnitude.\\n # -----------------------------------------------------------------------\\n\\n edges = [(n1, n2, 1 / d) for n1, n2, d in graph.edges() if d > 0]\\n inverted_graph = Graph(from_list=edges) # create G_inverted.\\n capacity_graph = Graph() # Create structure to record capacity left.\\n flow_graph = Graph() # Create structure to record flows.\\n\\n while unassigned_flow:\\n # 1. find the best path\\n d, path = shortest_path(inverted_graph, start, end)\\n if d == float(\\\"inf\\\"): # then there is no path, and we must exit.\\n return total_flow, flow_graph\\n # else: use the path and lookup the actual flow from the capacity graph.\\n\\n path_flow = min([min(d, capacity_graph.edge(s, e, default=float(\\\"inf\\\"))) for s, e, d in graph.edges(path=path)])\\n\\n # 2. update the unassigned flow.\\n unassigned_flow -= path_flow\\n total_flow += path_flow\\n\\n # 3. record the flows and update the inverted graph, so that it is\\n # ready for the next iteration.\\n edges = graph.edges(path)\\n for n1, n2, d in edges:\\n # 3.a. recording:\\n v = flow_graph.edge(n1, n2, default=None)\\n if v is None:\\n flow_graph.add_edge(n1, n2, path_flow)\\n c = graph.edge(n1, n2) - path_flow\\n else:\\n flow_graph.add_edge(n1, n2, value=v + path_flow)\\n c = graph.edge(n1, n2) - (v + path_flow)\\n capacity_graph.add_edge(n1, n2, c)\\n\\n # 3.b. updating:\\n # if there is capacity left: update with new 1/capacity\\n # else: remove node, as we can't do 1/zero.\\n if c > 0:\\n inverted_graph.add_edge(n1, n2, 1 / c)\\n else:\\n inverted_graph.del_edge(n1, n2)\\n return total_flow, flow_graph\",\n \"def _dfs(\\n self, kg: KG, entity: Vertex, is_reverse: bool = False\\n ) -> List[Walk]:\\n self.sampler.visited = set()\\n walks: List[Walk] = []\\n assert self.max_walks is not None\\n\\n rng = np.random.RandomState(self.random_state)\\n\\n while len(walks) < self.max_walks:\\n sub_walk: Walk = (entity,)\\n d = 1\\n while d // 2 < self.max_depth:\\n pred_obj = self.sampler.sample_hop(\\n kg, sub_walk, d // 2 == self.max_depth - 1, is_reverse\\n )\\n if pred_obj is None:\\n break\\n\\n if is_reverse:\\n if (\\n pred_obj[0] in self.communities\\n and rng.random() < self.hop_prob\\n ):\\n community_nodes = self.labels_per_community[\\n self.communities[pred_obj[0]]\\n ]\\n sub_walk = (\\n pred_obj[1],\\n rng.choice(community_nodes),\\n ) + sub_walk\\n else:\\n sub_walk = (pred_obj[1], pred_obj[0]) + sub_walk\\n else:\\n if (\\n pred_obj[1] in self.communities\\n and rng.random() < self.hop_prob\\n ):\\n community_nodes = self.labels_per_community[\\n self.communities[pred_obj[1]]\\n ]\\n sub_walk += (\\n pred_obj[0],\\n rng.choice(community_nodes),\\n )\\n else:\\n sub_walk += (pred_obj[0], pred_obj[1])\\n d = len(sub_walk) - 1\\n walks.append(sub_walk)\\n return list(walks)\",\n \"def dfs(self, starting_vertex, destination_vertex):\\n \\\"\\\"\\\" LIFO\\n Create a stack\\n Create a set to store visited\\n PUSH starting vertex into an array (STACK)\\n While the STACK is NOT empty \\n get((pop) first PATH vertex\\n get Vertex from END of PATH\\n check if NOT visited\\n mark as visited\\n check if vertex is destination_vertex\\n If TRUE, return path \\n PUSH path to ALL of neighbors\\n make copy of current path\\n add neighbor to path copy\\n PUSH path copy\\n \\\"\\\"\\\" \\n s = Stack() # Create a stack\\n s.push([starting_vertex]) # PUSH starting vertex into an array (STACK)\\n visited = set() # Create a set to store visited\\n\\n while s.size() > 0: # While the STACK is NOT empty\\n path = s.pop() # get(pop) first PATH vertex)\\n v = path[-1] # get Vertex from END of PATH \\n\\n while v not in visited: # check if NOT visited\\n visited.add(v) # mark as visited\\n\\n if v == destination_vertex: # check if vertex is destination_vertex\\n return path # If TRUE, return path \\n\\n for n in self.get_neighbors(v): # PUSH path to ALL of neighbors\\n path_c = path[:] # make copy of current path\\n # path_c.extend([n]) # add neighbor to path copy\\n path_c.append(n) # add neighbor to path copy\\n s.push(path_c) # PUSH path copy\",\n \"def generate_simple_flows(tgen_names, num_bots, bot_msg_size, bot_msg_rate, num_comps, comp_msg_size, comp_msg_rate):\\n bot_tgen_ips = [TGEN_IP_PATTERN.format(TGEN_SUBNET_BASE + i) for i in range(num_bots)]\\n bot_tgen_ports = [TGEN_PORT_BASE + i for i in range(num_bots)]\\n\\n # competitor IPs and port numbers start after those assigned to the bots\\n comp_tgen_ips = [TGEN_IP_PATTERN.format(TGEN_SUBNET_BASE + i) for i in range(num_bots, num_bots+num_comps)]\\n comp_tgen_ports = [TGEN_PORT_BASE + i for i in range(num_bots, num_bots+num_comps)]\\n\\n # build up flows for bots. Each bot talks to every other bot.\\n bot_flows = {}\\n for i in range(num_bots):\\n bot_flows[i] = {\\\"flows\\\": [], \\\"tgen_name\\\": tgen_names[i]}\\n\\n # add a flow for each neighbor bot\\n for j in range(len(bot_tgen_ips)):\\n # don't add flows to self\\n if i != j:\\n # send from a unique source port based on the DESTINATION node.\\n # use a destination port based on the SOURCE node number\\n bot_flows[i][\\\"flows\\\"].append({\\\"src_port\\\": bot_tgen_ports[j],\\n \\\"dst_ip\\\": bot_tgen_ips[j],\\n \\\"dst_port\\\": bot_tgen_ports[i],\\n \\\"msg_rate\\\": bot_msg_rate,\\n \\\"msg_size\\\": bot_msg_size,\\n })\\n\\n # build up flows for competitor nodes. Each competitor node talks to every other competitor node.\\n comp_flows = {}\\n for i in range(num_comps):\\n comp_flows[i] = {\\\"flows\\\": [], \\\"tgen_name\\\": tgen_names[i+num_bots]}\\n\\n # add a flow for each neighbor bot\\n for j in range(len(comp_tgen_ips)):\\n # don't add flows to self\\n if i != j:\\n # send from a unique source port based on the DESTINATION node.\\n # use a destination port based on the SOURCE node number\\n comp_flows[i][\\\"flows\\\"].append({\\\"src_port\\\": comp_tgen_ports[j],\\n \\\"dst_ip\\\": comp_tgen_ips[j],\\n \\\"dst_port\\\": comp_tgen_ports[i],\\n \\\"msg_rate\\\": comp_msg_rate,\\n \\\"msg_size\\\": comp_msg_size,\\n })\\n\\n return bot_flows, comp_flows\",\n \"def dfs(self):\\n def add_to_stack(stack, done, src, path):\\n for dest in self.edges[src]:\\n if dest not in done:\\n for step_path in self.edges[src][dest]:\\n stack.append((dest, step_path, path))\\n done.add(src)\\n stack = [] # Stack of steps to take\\n done = set() # Nodes we've visited\\n # Seed the stack with all edges from the start cell.\\n add_to_stack(stack, done, self.start_cell, '')\\n while stack:\\n (src, step_path, path) = stack.pop()\\n path = path + step_path\\n if src == self.exit_cell:\\n return path\\n add_to_stack(stack, done, src, path)\\n return '' # No path found.\",\n \"def __dynamicThroughput( self, sourceSEs, destSEs ):\\n res = self.__getTimeToStart()\\n if not res['OK']:\\n gLogger.error( res['Message'] )\\n return {}\\n channelInfo = res['Value']\\n\\n timeToSite = {} # Maintains time to site including previous hops\\n siteAncestor = {} # Maintains the ancestor channel for a site\\n tree = {} # Maintains replication tree\\n while len( destSEs ) > 0:\\n minTotalTimeToStart = float( \\\"inf\\\" )\\n candidateChannels = []\\n sourceActiveSEs = self.__getActiveSEs( sourceSEs )\\n for destSE in destSEs:\\n destSites = self.__getChannelSitesForSE( destSE )\\n localTransfer = False\\n for destSite in destSites:\\n if localTransfer: break\\n for sourceSE in sourceActiveSEs:\\n if localTransfer: break\\n sourceSites = self.__getChannelSitesForSE( sourceSE )\\n for sourceSite in sourceSites:\\n if localTransfer: break\\n channelName = '%s-%s' % ( sourceSite, destSite )\\n if channelInfo.has_key( channelName ):\\n channelID = channelInfo[channelName]['ChannelID']\\n if tree.has_key( channelID ):\\n continue\\n channelTimeToStart = channelInfo[channelName]['TimeToStart']\\n if timeToSite.has_key( sourceSE ):\\n totalTimeToStart = timeToSite[sourceSE] + channelTimeToStart + self.sigma\\n else:\\n totalTimeToStart = channelTimeToStart\\n #print '%s-%s %s %s' % (sourceSE,destSE,channelTimeToStart,totalTimeToStart)\\n localTransfer = ( sourceSite == destSite )\\n if localTransfer or totalTimeToStart < minTotalTimeToStart:\\n minTotalTimeToStart = totalTimeToStart\\n selectedPathTimeToStart = totalTimeToStart\\n candidateChannels = [( sourceSE, destSE, channelID )]\\n elif totalTimeToStart == minTotalTimeToStart:\\n candidateChannels.append( ( sourceSE, destSE, channelID ) )\\n\\n #minTotalTimeToStart = totalTimeToStart\\n #selectedPathTimeToStart = totalTimeToStart\\n #selectedSourceSE = sourceSE\\n #selectedDestSE = destSE\\n #selectedChannelID = channelID\\n else:\\n errStr = 'StrategyHandler.__dynamicThroughput: Channel not defined'\\n gLogger.warn( errStr, channelName )\\n\\n #print 'Selected %s \\\\n' % selectedPathTimeToStart\\n\\n random.shuffle( candidateChannels )\\n selectedSourceSE, selectedDestSE, selectedChannelID = candidateChannels[0]\\n timeToSite[selectedDestSE] = selectedPathTimeToStart\\n siteAncestor[selectedDestSE] = selectedChannelID\\n\\n if siteAncestor.has_key( selectedSourceSE ):\\n waitingChannel = siteAncestor[selectedSourceSE]\\n else:\\n waitingChannel = False\\n tree[selectedChannelID] = {}\\n tree[selectedChannelID]['Ancestor'] = waitingChannel\\n tree[selectedChannelID]['SourceSE'] = selectedSourceSE\\n tree[selectedChannelID]['DestSE'] = selectedDestSE\\n tree[selectedChannelID]['Strategy'] = 'DynamicThroughput'\\n sourceSEs.append( selectedDestSE )\\n destSEs.remove( selectedDestSE )\\n return tree\",\n \"def compute_unequal_flow_allocations(target_graph, K=3):\\n\\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\\n flow_allocation_seed_number = 0xDEAD_BEEF\\n np.random.seed(flow_allocation_seed_number)\\n flows = []\\n link_utilization = {}\\n for node in target_graph.nodes:\\n possible_destination_nodes = set(target_graph.nodes) - {node}\\n destination_node = np.random.choice(list(possible_destination_nodes), 1, \\n replace=False).item()\\n shortest_path = nx.shortest_path(target_graph, node, destination_node)\\n the_flow = Flow( source_node = node\\n , destination_node = destination_node\\n , flow_tx_rate = 10.0\\n , paths = [shortest_path]\\n , splitting_ratio = [1.0]\\n )\\n flows.append(the_flow)\\n\\n return flow_allocation_seed_number, flows\",\n \"def bfs(self, s):\\n g = Graph(attr={DIRECTED: True})\\n root = self.get_vertex(s)\\n root.attributes[DISCOVERED] = True\\n q = collections.deque()\\n adjacent_type = '+' if DIRECTED in self.attr and self.attr[\\n DIRECTED] else None\\n # Insert root node in graph and queue\\n g.add_vertex(root)\\n q.append(s)\\n\\n while (len(q) > 0):\\n v = q.popleft()\\n for e in self.get_adjacent_vertices_by_vertex(v, adjacent_type):\\n w = self.get_vertex(e)\\n if DISCOVERED not in w.attributes or w.attributes[\\n DISCOVERED] is False:\\n w.attributes[DISCOVERED] = True\\n q.append(w.id)\\n g.add_vertex(w)\\n g.add_edge(edge.Edge(v, e), True)\\n return g\",\n \"def random_one_graph(n):\\n return nx.fast_gnp_random_graph(n, 1/(n*n), directed=True)\",\n \"def main():\\n n = int(input(\\\"Enter the number of nodes: \\\"))\\n m = int(input(\\\"Enter the number of edges: \\\"))\\n \\n adjList = [[] for i in range(n)]\\n \\n print(\\\"Enter the edges: \\\")\\n for i in range(m):\\n x, y = input().split(\\\" \\\")\\n x = int(x)\\n y = int(y)\\n adjList[x].append(y)\\n adjList[y].append(x)\\n \\n s = int(input(\\\"Enter the source: \\\"))\\n \\n DFS(adjList, s, n)\",\n \"def dfs_r(self, s):\\n g = Graph(attr={DIRECTED: True})\\n return self.dfs_rec(g, ('#', s))\",\n \"def dijkstra(self, source=None, destination=None):\\n for vertex in self.vertices():\\n vertex.d = sys.maxint\\n if not source:\\n source = self.vertices()[0]\\n q = simply_python.data_structures.FIFO_dict()\\n source.d = 0\\n q.append(source)\\n while not q.isempty():\\n source = q.pop()\\n print source\\n print source.d\\n d = source.d\\n for out_vertex in self.out_vertices(source):\\n if out_vertex.d == sys.maxint:\\n out_vertex.d = d + 1\\n q.append(out_vertex)\\n if out_vertex == destination:\\n return out_vertex.d\\n return d\",\n \"def shortest_path(self, source, target):\\r\\n key = self.d.keys()\\r\\n #check that endpoints are in graph\\r\\n if source not in key or target not in key:\\r\\n raise KeyError(str(source) + \\\" and \\\" + str(target) + \\\" must be in graph\\\")\\r\\n #initialize V,Q and M\\r\\n V = []\\r\\n vis = dict()\\r\\n Q = deque()\\r\\n Q.append(source)\\r\\n M = set(source)\\r\\n #while target has not been visited\\r\\n while target not in M:\\r\\n #take first element of Q\\r\\n current = Q.popleft()\\r\\n #add element to visited\\r\\n V.append(current)\\r\\n neighbors = self.d[current]\\r\\n #for each neighbor of element\\r\\n for n in neighbors:\\r\\n #if element has not been checked, add it to queue\\r\\n #also save traveled edge in visited\\r\\n if n not in M:\\r\\n Q.append(n)\\r\\n vis.update({n:current})\\r\\n M.add(n)\\r\\n L = [target]\\r\\n #reverse the order of the traveled edges\\r\\n while L[-1] in vis.keys():\\r\\n L.append(vis[L[-1]])\\r\\n return L[::-1]\",\n \"def sources(self):\\n return [x for x in self if self.in_degree(x)==0]\",\n \"def gen_task_sets_simplegen(nsets):\\n start = time()\\n eval_task_sets = []\\n for util in utils:\\n task_sets = []\\n for i in range(nsets):\\n ts = synth.simplegen(i, util, implicit_deadlines=True)\\n synth.synth_c_pmf(ts, distribution_cls=lib.ExpExceedDist)\\n synth.set_fixed_priorities(ts)\\n task_sets.append(ts)\\n eval_task_sets.append(task_sets)\\n stop = time()\\n print('Task Set Generation SimpleGen: %.3fs' % (stop - start))\\n pickle.dump(eval_task_sets, open(task_sets_path + 'task_sets_simplegen', 'wb'))\",\n \"def FixedInGraph(N,degrees,replace = True):\\n \\n conn = np.zeros([N*degrees,2])\\n nodes = np.arange(0,N)\\n ii = 0\\n for i in range(N):\\n # for deg in range(degrees):\\n source = np.random.choice(nodes,size =degrees,replace=replace)\\n conn[ii:ii+len(source),0] = source\\n conn[ii:ii+len(source),1] = i\\n ii+=len(source) \\n return conn\",\n \"def getDistsSourceToNodes(self):\\r\\n self.run()\\r\\n return self.dists_so_far\",\n \"def _ism_get_mirror_sources(source, receiver, walls, order_threshold, mirrors_threshold):\\n logger.info(\\\"_ism_get_mirror_sources: Determining mirror sources.\\\")\\n model = ism.Model(walls=walls, source=source, receiver=receiver, max_order=order_threshold)\\n mirrors = model.determine(strongest=mirrors_threshold)\\n yield from mirrors\",\n \"def shortestPath(graph, start, end, maxOutdistance, toPrint = False):\\r\\n return DFS(graph, start, end, [], None, sys.maxsize, sys.maxsize, 0, maxOutdistance, toPrint)\",\n \"def Run(self):\\r\\n # start all the flows along with updating related flow's transfer time\\r\\n while self.sched.toStartFlows:\\r\\n # the first flow is with earliest startTime\\r\\n curStartFlow = self.sched.toStartFlows[0]\\r\\n # update flows if there are flows has already finished\\r\\n while self.sched.runningFlows:\\r\\n # the first flow is with earliest finishTime\\r\\n toFinishFlow = self.sched.runningFlows[0]\\r\\n\\r\\n if toFinishFlow.finishTime <= curStartFlow.startTime:\\r\\n # remove this flow from running flows\\r\\n self.sched.runningFlows.remove(toFinishFlow)\\r\\n # add this flow to finished flows\\r\\n self.sched.finishedFlows.append(toFinishFlow)\\r\\n # Update related flow's transfer time in removing a flow\\r\\n self.sched.UpdateFlow(toFinishFlow, \\\"remove\\\")\\r\\n # Resort runningFlows by endTime\\r\\n self.sched.runningFlows.sort(key=lambda x: x.finishTime)\\r\\n else:\\r\\n break\\r\\n # insert current start flow to running list\\r\\n self.sched.runningFlows.append(curStartFlow)\\r\\n # Update related flow's transfer time in removing a flow\\r\\n self.sched.UpdateFlow(curStartFlow, \\\"insert\\\")\\r\\n # Resort runningFlows by endTime\\r\\n self.sched.runningFlows.sort(key=lambda x: x.finishTime)\\r\\n # remove this flow from start list\\r\\n self.sched.toStartFlows.remove(curStartFlow)\\r\\n\\r\\n # Now, all the flows are started\\r\\n # Iteratively update flow's transfer time in running list until all the flows are finished\\r\\n while self.sched.runningFlows:\\r\\n # the first flow is always with earliest finish Time\\r\\n curFinishFlow = self.sched.runningFlows[0]\\r\\n\\r\\n # remove it from running list\\r\\n self.sched.runningFlows.remove(curFinishFlow)\\r\\n # insert it to finished flows\\r\\n self.sched.finishedFlows.append(curFinishFlow)\\r\\n # Update related flow's transfer time in removing a flow\\r\\n self.sched.UpdateFlow(curFinishFlow, \\\"remove\\\")\\r\\n # Resort runningFlows by endTime\\r\\n self.sched.runningFlows.sort(key=lambda x: x.finishTime)\\r\\n\\r\\n # Finally, all the flows are finished\\r\\n self.sched.PrintFlows()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5869763","0.5869763","0.5623528","0.558636","0.55374354","0.5450709","0.54248506","0.54232466","0.53542936","0.532742","0.53266317","0.5317662","0.53176224","0.53126985","0.5301199","0.528309","0.5279385","0.52754855","0.5249356","0.52429557","0.5217097","0.5154524","0.51507854","0.5139238","0.51364726","0.51276255","0.51244694","0.5123479","0.51210636","0.5112041","0.5103908","0.50957704","0.50949836","0.5064064","0.50511616","0.50417256","0.5028874","0.5026915","0.5002274","0.49910963","0.4986026","0.49835023","0.49786785","0.49733484","0.4969613","0.49684167","0.49618754","0.49356717","0.49352872","0.49317694","0.49298662","0.49288583","0.49187636","0.4916468","0.49046266","0.4902805","0.48989353","0.48912162","0.4891003","0.48808983","0.48653907","0.48592296","0.48573864","0.48542276","0.48474053","0.4847021","0.48454717","0.48431316","0.4841169","0.483272","0.4831974","0.48312744","0.48292202","0.48289543","0.48275706","0.48269832","0.48225614","0.48184204","0.48181635","0.48150727","0.48143166","0.48128462","0.48108304","0.48100904","0.48072034","0.48047206","0.48021665","0.47976616","0.4788543","0.47831577","0.47812092","0.47783628","0.47734025","0.47693187","0.47692323","0.476902","0.47624928","0.4761566","0.47607106","0.4760552"],"string":"[\n \"0.5869763\",\n \"0.5869763\",\n \"0.5623528\",\n \"0.558636\",\n \"0.55374354\",\n \"0.5450709\",\n \"0.54248506\",\n \"0.54232466\",\n \"0.53542936\",\n \"0.532742\",\n \"0.53266317\",\n \"0.5317662\",\n \"0.53176224\",\n \"0.53126985\",\n \"0.5301199\",\n \"0.528309\",\n \"0.5279385\",\n \"0.52754855\",\n \"0.5249356\",\n \"0.52429557\",\n \"0.5217097\",\n \"0.5154524\",\n \"0.51507854\",\n \"0.5139238\",\n \"0.51364726\",\n \"0.51276255\",\n \"0.51244694\",\n \"0.5123479\",\n \"0.51210636\",\n \"0.5112041\",\n \"0.5103908\",\n \"0.50957704\",\n \"0.50949836\",\n \"0.5064064\",\n \"0.50511616\",\n \"0.50417256\",\n \"0.5028874\",\n \"0.5026915\",\n \"0.5002274\",\n \"0.49910963\",\n \"0.4986026\",\n \"0.49835023\",\n \"0.49786785\",\n \"0.49733484\",\n \"0.4969613\",\n \"0.49684167\",\n \"0.49618754\",\n \"0.49356717\",\n \"0.49352872\",\n \"0.49317694\",\n \"0.49298662\",\n \"0.49288583\",\n \"0.49187636\",\n \"0.4916468\",\n \"0.49046266\",\n \"0.4902805\",\n \"0.48989353\",\n \"0.48912162\",\n \"0.4891003\",\n \"0.48808983\",\n \"0.48653907\",\n \"0.48592296\",\n \"0.48573864\",\n \"0.48542276\",\n \"0.48474053\",\n \"0.4847021\",\n \"0.48454717\",\n \"0.48431316\",\n \"0.4841169\",\n \"0.483272\",\n \"0.4831974\",\n \"0.48312744\",\n \"0.48292202\",\n \"0.48289543\",\n \"0.48275706\",\n \"0.48269832\",\n \"0.48225614\",\n \"0.48184204\",\n \"0.48181635\",\n \"0.48150727\",\n \"0.48143166\",\n \"0.48128462\",\n \"0.48108304\",\n \"0.48100904\",\n \"0.48072034\",\n \"0.48047206\",\n \"0.48021665\",\n \"0.47976616\",\n \"0.4788543\",\n \"0.47831577\",\n \"0.47812092\",\n \"0.47783628\",\n \"0.47734025\",\n \"0.47693187\",\n \"0.47692323\",\n \"0.476902\",\n \"0.47624928\",\n \"0.4761566\",\n \"0.47607106\",\n \"0.4760552\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5799766"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":24590,"cells":{"query":{"kind":"string","value":"Returns a set of flows st. there will be a single flow sourced from each node in the network with a destination randomly chosen from the set V / {s} where V is the set of nodes in the graph and s is the source node of the flow. Flows are split over the three shortest paths connecting the sender to the receiver in such a way as to minimize the utilization of the most utilized link in the network."},"document":{"kind":"string","value":"def compute_unequal_flow_allocations(target_graph, K=3):\n\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n flow_allocation_seed_number = 0xDEAD_BEEF\n np.random.seed(flow_allocation_seed_number)\n flows = []\n link_utilization = {}\n for node in target_graph.nodes:\n possible_destination_nodes = set(target_graph.nodes) - {node}\n destination_node = np.random.choice(list(possible_destination_nodes), 1, \n replace=False).item()\n shortest_path = nx.shortest_path(target_graph, node, destination_node)\n the_flow = Flow( source_node = node\n , destination_node = destination_node\n , flow_tx_rate = 10.0\n , paths = [shortest_path]\n , splitting_ratio = [1.0]\n )\n flows.append(the_flow)\n\n return flow_allocation_seed_number, flows"},"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_paths_for_flow(F, s, f):\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links","def get_paths_for_flow(F, s, f):\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links","def traverse_graph(F, f, s, t, u, sr):\n def get_paths_for_flow(F, s, f):\n \"\"\"\n RETURNS\n A set of outgoing links and corresponding splitting ratios for flow f\n at node s\n \"\"\"\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links\n \n if u == t:\n return [([t], sr)]\n\n outgoing_links = get_paths_for_flow(F, u, f)\n paths_to_t = []\n\n for ((current_node, next_hop), split_ratio) in outgoing_links:\n paths_from_u_to_t = traverse_graph(F, f, s, t, next_hop, split_ratio) \n paths_to_t.extend(paths_from_u_to_t)\n\n paths_to_t_with_u = []\n for path in paths_to_t:\n nodes, sr = path\n new_path = [u] + nodes\n paths_to_t_with_u.append((new_path, sr))\n\n return paths_to_t_with_u","def compute_equal_flow_allocations(target_graph, K=3):\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n flow_allocation_seed_number = 0xDEAD_BEEF\n np.random.seed(flow_allocation_seed_number)\n flows = []\n for node in target_graph.nodes:\n possible_destination_nodes = set(target_graph.nodes) - set([node])\n [destination_node] = np.random.choice(list(possible_destination_nodes), 1, replace=False)\n # shortest_paths = all_shortest_paths(target_graph, node, destination_node.item())\n shortest_paths = sorted(nx.all_simple_paths(target_graph, node, destination_node.item(),\n cutoff=3),\n key=lambda p: len(p))\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\n the_flow = Flow( source_node = node\n , destination_node = destination_node.item()\n , flow_tx_rate = 10.0\n , paths = k_shortest_paths\n , splitting_ratio = [1/K]*K\n )\n flows.append(the_flow)\n \n return flow_allocation_seed_number, flows","def get_dfs(self, s):\n results = []\n # mark all the vertices as not visited\n visited = [False] * (len(self.graph))\n self._dfs_recursive(s, visited, results)\n return results","def max_flow(self, source, sink):\n\n path = self.valid_path(source, sink, [])\n\n while path:\n # get the maximum possible flow that can be taken from this path:\n max_flow = min([edge.capacity for edge in path])\n for edge in path:\n self.edges[edge] += max_flow\n path = self.valid_path(source, sink, [])\n\n # Compute all the flows from the neighbors of source:\n return sum([self.edges[edge] for edge in self.adjacents[source]])","def compute_path_hopping_flow_allocations(target_graph, K=3):\n flow_allocation_seed_number = 0xCAFE_BABE\n np.random.seed(flow_allocation_seed_number)\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n link_utilization = {(u, v): 0.0 for u, v in target_graph.edges}\n node_capacity = {u: 0.0 for u in target_graph.nodes}\n flows = []\n while True:\n source_node, destination_node = flow_selection_fn(target_graph.nodes, 2, replace=False)\n print(source_node, destination_node)\n\n shortest_paths = sorted(nx.all_simple_paths(target_graph, source_node, destination_node,\n cutoff=3),\n key=lambda p: len(p))\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\n\n # flow_tx_rate = np.random.uniform() * 10\n flow_tx_rate = 1.0\n # if node_capacity[source_node] + flow_tx_rate > LINK_CAPACITY:\n # break\n node_capacity[source_node] += flow_tx_rate\n capacity_was_exceeded = False \n for path in [nx.utils.pairwise(p_i) for p_i in k_shortest_paths]:\n for u, v in [sorted(h_i) for h_i in path]:\n flow_rate_per_subpath = flow_tx_rate / K\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\n capacity_was_exceeded = True\n break\n link_utilization[u, v] += flow_rate_per_subpath\n if capacity_was_exceeded:\n break\n\n if capacity_was_exceeded:\n break\n\n the_flow = Flow( source_node = source_node\n , destination_node = destination_node\n , flow_tx_rate = flow_tx_rate\n , paths = k_shortest_paths\n , splitting_ratio = [1.0/K]*K\n )\n flows.append(the_flow)\n return flows, link_utilization","def ford_fulkerson_algorithm(graph: np.ndarray, source: int, sink: int) -> np.ndarray:\r\n\r\n residual_graph = copy.deepcopy(graph)\r\n row = len(residual_graph)\r\n parent = [-1] * row\r\n max_flow = 0\r\n\r\n if source == sink or sink < 0 or source < 0 or source >= row or sink >= row:\r\n raise WrongInputException('Wrong input source/sink vertice(s)')\r\n\r\n while bfs(residual_graph, row, source, sink, parent):\r\n\r\n path_flow = float(\"Inf\")\r\n s = sink\r\n while s != source:\r\n path_flow = min(path_flow, residual_graph[parent[s]][s])\r\n s = parent[s]\r\n\r\n max_flow += path_flow\r\n\r\n v = sink\r\n while v != source:\r\n u = parent[v]\r\n residual_graph[u][v] -= path_flow\r\n residual_graph[v][u] += path_flow\r\n v = parent[v]\r\n print(\"Max flow: %d\" % max_flow)\r\n\r\n return residual_graph","def compute_greedy_flow_allocations( target_graph\n , flow_selection_fn\n , seed_number=DEFAULT_SEED_NUMBER):\n\n flow_allocation_seed_number = seed_number\n np.random.seed(flow_allocation_seed_number)\n\n link_utilization = {tuple(sorted(link_tuple)): 0.0 for link_tuple in target_graph.edges}\n flows = []\n\n while True:\n capacity_was_exceeded = False\n\n source_node, destination_node = flow_selection_fn(target_graph.nodes)\n flow_tx_rate = np.random.uniform(FLOW_TX_RATE_LOWER_BOUND, FLOW_TX_RATE_UPPER_BOUND)\n\n connecting_paths = list(node_disjoint_paths(target_graph, source_node, destination_node))\n disjoint_path_count = len(connecting_paths)\n flow_rate_per_subpath = flow_tx_rate / disjoint_path_count\n for path in [nx.utils.pairwise(p_i) for p_i in connecting_paths]:\n for u, v in [tuple(sorted(t_i)) for t_i in path]:\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\n capacity_was_exceeded = True\n break\n link_utilization[u, v] += flow_rate_per_subpath\n if capacity_was_exceeded:\n break\n if capacity_was_exceeded:\n break\n\n the_flow = Flow( source_node = source_node\n , destination_node = destination_node\n , flow_tx_rate = flow_tx_rate\n , paths = connecting_paths\n , splitting_ratio = [1.0/disjoint_path_count]*disjoint_path_count\n )\n flows.append(the_flow)\n return flows, link_utilization","def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\n demand: float,\n routing: np.ndarray) -> np.ndarray:\n edge_mapping = {edge: i for i, edge in\n enumerate(sorted(self.graph.edges))}\n\n link_utilisation = np.zeros(self.num_edges)\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\n node_flow[flow[0]] = demand\n\n to_explore = [flow[0]]\n while to_explore:\n current_node = to_explore.pop(0)\n current_flow = node_flow[current_node]\n\n # this is the flow destination node so we absorb all flow\n if current_node == flow[1]:\n node_flow[current_node] = 0.0\n continue\n\n # push the flow at this node over all edges\n for edge in self.graph.out_edges(current_node):\n edge_index = edge_mapping[edge]\n ratio = routing[edge_index]\n flow_to_send = ratio * current_flow\n # only send flow if greater than epsilon (so no 'infinite' loops)\n if flow_to_send > 1.e-8:\n node_flow[edge[1]] += ratio * current_flow\n # all important step, update our output\n link_utilisation[edge_index] += ratio * current_flow\n # have updated the dst so add it to the list of things to do\n to_explore.append(edge[1])\n # we've moved all the flow from this node now, so reset back to zero\n node_flow[current_node] = 0.0\n\n return link_utilisation","def DRBFS(self, flow, edge_mark):\n\t\t# Distance flag for each node\n\t\td = {v:float('inf') for v in self.topo.nodes}\n\t\t# Parent node for each node\n\t\tpa = {v:-1 for v in self.topo.nodes}\n\t\t# Request info\n\t\ts = flow[0]\n\t\tt = flow[1]\n\n\t\t# BFS to find a min-hop path\n\t\tqueue = [s]; hdr = 0; d[s] = 0\n\t\twhile hdr < len(queue):\n\t\t\tu = queue[hdr]\n\t\t\thdr += 1\n\n\t\t\tfor v in self.topo.topo.neighbors(u):\n\t\t\t\tif edge_mark[(u, v)] or d[v] <= d[u] + 1:\n\t\t\t\t\tcontinue\n\t\t\t\tqueue.append(v)\n\t\t\t\td[v] = d[u] + 1\n\t\t\t\tpa[v] = u\n\t\t\t\tif v == t:\n\t\t\t\t\t# This is because when BFS on edges, the first time reaching t meaning the smallest hop it can be reached\n\t\t\t\t\thdr = len(queue)\n\t\t\t\t\tbreak\n\n\t\tif d[t] == float('inf'):\n\t\t\treturn False\n\n\t\tp = [t]; v = t\n\t\twhile v != s and v != -1:\n\t\t\tv = pa[v]\n\t\t\tp.append(v)\n\t\tp.reverse()\n\n\t\treturn p","def sorted_nodes(self):\r\n def is_source(node, connections):\r\n for connection in connections:\r\n if node == connection[1]:\r\n return False\r\n return True\r\n\r\n def source_connections(node, connections):\r\n conns = set()\r\n for connection in connections:\r\n if node == connection[0]:\r\n conns.add(connection)\r\n return conns\r\n\r\n nodes = set(self.nodes.values())\r\n connections = self.connections.copy()\r\n sorted_nodes = []\r\n\r\n # Find source nodes:\r\n source_nodes = set([n for n in nodes if is_source(n, connections)])\r\n\r\n # while S is non-empty do\r\n while source_nodes:\r\n # remove a node n from S\r\n node = source_nodes.pop()\r\n # insert n into L\r\n sorted_nodes.append(node)\r\n\r\n # for each node m with an edge e from n to m do\r\n s_connections = source_connections(node, connections)\r\n for connection in s_connections:\r\n # remove edge e from the graph\r\n m = connection[1]\r\n connections.remove(connection)\r\n # if m has no other incoming edges then\r\n # insert m into S\r\n if is_source(m, connections):\r\n source_nodes.add(m)\r\n\r\n # if graph has edges then\r\n # output error message (graph has at least one cycle)\r\n # else\r\n # output message (proposed topologically sorted order: L)\r\n\r\n if connections:\r\n raise Exception(\"Steram has at least one cycle (%d connections left of %d)\" % (len(connections), len(self.connections)))\r\n\r\n return sorted_nodes","def flowers(self):\n return self._flowers","def test_sources():\n g = Graph(from_list=[\n (1, 3, 1),\n (2, 4, 1),\n (2, 5, 1),\n (3, 5, 1),\n (4, 6, 1),\n (5, 6, 1),\n ])\n g.add_node(7)\n s = g.sources(5)\n e = {1, 2, 3}\n assert s == e\n\n s2 = g.sources(1)\n e2 = set()\n assert s2 == e2, s2\n\n s3 = g.sources(6)\n e3 = {1, 2, 3, 4, 5}\n assert s3 == e3\n\n s4 = g.sources(7)\n e4 = set()\n assert s4 == e4","def dijkstra(self, s, t):\n l = []\n dist = {}\n prev = {}\n discovered = {}\n for v in self.get_vertices():\n dist[v] = float('inf')\n prev[v] = None\n discovered[v] = False\n dist[s] = 0\n l.append((s, dist[s]))\n while len(l) != 0:\n u = min(l, key=lambda x: x[1])\n l.remove(u)\n u = u[0]\n discovered[u] = True\n if u == t:\n break\n for v in self.get_adjacent_vertices_by_vertex(u):\n if not discovered[v]:\n alt = dist[u] + self.get_edge((u, v)).attr[\"WEIGHT\"]\n if alt < dist[v]:\n dist[v] = alt\n prev[v] = u\n l.append((v, dist[v]))\n # Create a graph according to visited nodes store in prev array\n u = t\n g = Graph(attr={DIRECTED: True})\n while u is not None:\n g.add_vertex(vertex.Vertex(u, {\"WEIGHT\": dist[u]}))\n if prev[u] is not None:\n g.add_vertex(vertex.Vertex(prev[u], {\"WEIGHT\": dist[prev[u]]}))\n g.add_edge(edge.Edge(prev[u], u))\n u = prev[u]\n else:\n break\n return g","def get_flow_6frames(self, flows_forward, flows_backward, flows_forward2, flows_backward2):\n d = flows_forward2[0].shape[1]\n flows_backward3 = []\n for flows, flows2 in zip(flows_backward, flows_backward2):\n flow_list = []\n for i in range(d - 1, 0, -1):\n flow_n1 = flows2[:, i - 1, :, :, :]\n flow_n2 = flows[:, i + 1, :, :, :]\n flow_list.insert(0, flow_n1 + flow_warp(flow_n2, flow_n1.permute(0, 2, 3, 1)))\n flows_backward3.append(torch.stack(flow_list, 1))\n flows_forward3 = []\n for flows, flows2 in zip(flows_forward, flows_forward2):\n flow_list = []\n for i in range(2, d + 1):\n flow_n1 = flows2[:, i - 1, :, :, :]\n flow_n2 = flows[:, i - 2, :, :, :]\n flow_list.append(flow_n1 + flow_warp(flow_n2, flow_n1.permute(0, 2, 3, 1)))\n flows_forward3.append(torch.stack(flow_list, 1))\n return flows_backward3, flows_forward3","def dfs(self, s):\n g = Graph(attr={DIRECTED: True})\n adjacent_type = '+' if DIRECTED in self.attr and self.attr[\n DIRECTED] else None\n # Insert s root node in stack \n stack = collections.deque()\n # Initial node does not have origin, it is represented by # \n stack.append(('#', s))\n\n while (len(stack) > 0):\n (source, target) = stack.pop()\n w = self.get_vertex(target)\n if DISCOVERED not in w.attributes or w.attributes[\n DISCOVERED] is False:\n w.attributes[DISCOVERED] = True\n g.add_vertex(w)\n if (source != '#'):\n g.add_edge(edge.Edge(source, w.id), True)\n for e in self.get_adjacent_vertices_by_vertex(w.id,\n adjacent_type):\n stack.append((w.id, e))\n return g","def get_routing_solution(self):\n G = self.base_digraph\n s1 = self.sources[0]\n s2 = self.sources[1]\n t1 = self.destinations[0]\n t2 = self.destinations[1]\n\n try:\n m = Model('routing')\n m.setParam('OutputFlag', False)\n\n # variables,\n # We have one variable per edge per session\n # e is the dict of dict for the variables\n e = {}\n r = {}\n for i in [1,2]:\n e[i] = {}\n r[i] = m.addVar()\n for u,v in G.edges():\n e[i][u,v] = m.addVar(lb=0)\n\n m.update()\n\n obj = quicksum(r.values())\n m.setObjective(obj, GRB.MAXIMIZE)\n\n # constraints\n # 1. conservations of flow at all intermediate nodes\n # 2. capacity constraints for each edge\n\n for u,v in G.edges():\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\n\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\n\n for n in G.nodes():\n if n not in [s1, s2, t1, t2]:\n for i in [1, 2]:\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\n m.addConstr(inflow == outflow)\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n for u, v in G.edges():\n G[u][v]['Routing'] = {}\n G[u][v]['Routing'][1] = e[1][u,v].x\n G[u][v]['Routing'][2] = e[2][u,v].x\n return (m.objVal, r[1].x, r[2].x)\n else:\n # something went wrong...err...\n print \"Something was wrong, no optimal solution obtained\"\n return None, None, None\n\n except GurobiError:\n Print ('Error Report from Gurobi')","def set_random_session(self, G, degree_s):\n sorted_nodes = nx.topological_sort(G)\n num_nodes = G.number_of_nodes()\n\n # create sources and destinations of each of the sections\n # name the nodes to be the last 4 numbers\n srcs = [num_nodes, num_nodes + 1]\n dsts = [num_nodes + 2, num_nodes + 3]\n\n end_idx = int(0.3 * len(sorted_nodes))\n end_idx = max(end_idx, 2)\n for i in range(2):\n s = srcs[i]\n t = dsts[i]\n reachables = []\n iter_num = 0\n\n while len(reachables) == 0:\n iter_num += 1\n if iter_num > 100:\n end_idx = end_idx * 2\n\n # pick an entry point from the first 30%\n entry_point = random.choice(sorted_nodes[:end_idx])\n # print \"Source \", i\n # print \"candidates: \", sorted_nodes[:end_idx]\n # print \"entry point: \", entry_point\n # print \"all nodes: \", G.nodes()\n\n # pick a random point from the reachables\n reachables = nx.shortest_path(G, entry_point)\n del reachables[entry_point]\n #print \"reachables: \", reachables\n reachables = reachables.keys()\n\n exit_point = random.choice(reachables)\n #print \"exit_point: \", exit_point\n\n if degree_s[i]:\n G.add_edge(s, entry_point, weight=degree_s[i])\n G.add_edge(exit_point, t, weight=degree_s[i])\n else:\n # figure out the out_degree of entry point\n out_degree = np.sum(G[u][v]['weight'] for u,v in G.out_edges(entry_point))\n G.add_edge(s, entry_point, weight=out_degree)\n\n # figure out the int_degree of exit point\n in_degree = np.sum(G[u][v]['weight'] for u,v in G.in_edges(exit_point))\n G.add_edge(exit_point, t, weight=in_degree)\n\n edges = G.edges()\n for u, v in edges:\n par_num = int(G[u][v]['weight'])\n for i in range(par_num):\n self.add_edge(u, v)\n\n # set indices etc\n self.set_sources(srcs)\n self.set_destinations(dsts)\n self.set_indices()\n #print \"number of nodes: \" + str(self.number_of_nodes())\n #print \"number of edges: \" + str(self.number_of_edges())","def dfs_edges_generator(graph, source, reverse=...):\n ...","def find_flows(flows,\n source_query,\n target_query,\n flow_query=None,\n ignore_edges=None):\n if flow_query is not None:\n flows = flows[eval_selection(flows, '', flow_query)]\n\n if source_query is None and target_query is None:\n raise ValueError('source_query and target_query cannot both be None')\n\n elif source_query is None and target_query is not None:\n qt = eval_selection(flows, 'target', target_query)\n qs = (~eval_selection(flows, 'source', target_query) &\n ~flows.index.isin(ignore_edges or []))\n\n elif source_query is not None and target_query is None:\n qs = eval_selection(flows, 'source', source_query)\n qt = (~eval_selection(flows, 'target', source_query) &\n ~flows.index.isin(ignore_edges or []))\n\n else:\n qs = eval_selection(flows, 'source', source_query)\n qt = eval_selection(flows, 'target', target_query)\n\n f = flows[qs & qt]\n if source_query is None:\n internal_source = None\n else:\n internal_source = flows[qs & eval_selection(flows, 'target',\n source_query)]\n if target_query is None:\n internal_target = None\n else:\n internal_target = flows[qt & eval_selection(flows, 'source',\n target_query)]\n\n return f, internal_source, internal_target","def generate_simple_flows(tgen_names, num_bots, bot_msg_size, bot_msg_rate, num_comps, comp_msg_size, comp_msg_rate):\n bot_tgen_ips = [TGEN_IP_PATTERN.format(TGEN_SUBNET_BASE + i) for i in range(num_bots)]\n bot_tgen_ports = [TGEN_PORT_BASE + i for i in range(num_bots)]\n\n # competitor IPs and port numbers start after those assigned to the bots\n comp_tgen_ips = [TGEN_IP_PATTERN.format(TGEN_SUBNET_BASE + i) for i in range(num_bots, num_bots+num_comps)]\n comp_tgen_ports = [TGEN_PORT_BASE + i for i in range(num_bots, num_bots+num_comps)]\n\n # build up flows for bots. Each bot talks to every other bot.\n bot_flows = {}\n for i in range(num_bots):\n bot_flows[i] = {\"flows\": [], \"tgen_name\": tgen_names[i]}\n\n # add a flow for each neighbor bot\n for j in range(len(bot_tgen_ips)):\n # don't add flows to self\n if i != j:\n # send from a unique source port based on the DESTINATION node.\n # use a destination port based on the SOURCE node number\n bot_flows[i][\"flows\"].append({\"src_port\": bot_tgen_ports[j],\n \"dst_ip\": bot_tgen_ips[j],\n \"dst_port\": bot_tgen_ports[i],\n \"msg_rate\": bot_msg_rate,\n \"msg_size\": bot_msg_size,\n })\n\n # build up flows for competitor nodes. Each competitor node talks to every other competitor node.\n comp_flows = {}\n for i in range(num_comps):\n comp_flows[i] = {\"flows\": [], \"tgen_name\": tgen_names[i+num_bots]}\n\n # add a flow for each neighbor bot\n for j in range(len(comp_tgen_ips)):\n # don't add flows to self\n if i != j:\n # send from a unique source port based on the DESTINATION node.\n # use a destination port based on the SOURCE node number\n comp_flows[i][\"flows\"].append({\"src_port\": comp_tgen_ports[j],\n \"dst_ip\": comp_tgen_ips[j],\n \"dst_port\": comp_tgen_ports[i],\n \"msg_rate\": comp_msg_rate,\n \"msg_size\": comp_msg_size,\n })\n\n return bot_flows, comp_flows","def _compute_flows(paths):\n assert isinstance(paths, list)\n\n # allocate memory\n flows = np.zeros([len(paths), FLAGS.target_height, FLAGS.target_width, 2],\n dtype=np.float32)\n\n # load all images\n pbar = ProgressBar(max_value=len(paths))\n for i in range(len(paths)-1):\n im1 = skimage.io.imread(paths[i])\n im2 = skimage.io.imread(paths[i+1])\n\n im1 = cv2.cvtColor(im1, cv2.COLOR_RGB2GRAY)\n im2 = cv2.cvtColor(im2, cv2.COLOR_RGB2GRAY)\n im1 = skimage.transform.resize(\n im1, [FLAGS.target_height, FLAGS.target_width], preserve_range=True,\n mode='constant', anti_aliasing=True)\n im2 = skimage.transform.resize(\n im2, [FLAGS.target_height, FLAGS.target_width], preserve_range=True,\n mode='constant', anti_aliasing=True)\n flow = cv2.calcOpticalFlowFarneback(\n im1, im2, flow=None, pyr_scale=0.5, levels=3, winsize=15,\n iterations=3, poly_n=5, poly_sigma=1.2, flags=0)\n\n # store images\n flows[i] = flow\n pbar.update(i)\n\n # Replicate the flow for last frame\n flows[-1] = flow\n return flows","def make_flow_graph(interaction_logs):\n G = pgv.AGraph(directed=True)\n\n for module_id in interaction_logs['module_id'].unique():\n G.add_node(module_id)\n\n E = defaultdict(set)\n grouped = interaction_logs.groupby('user_id')\n for user_id, group in grouped:\n module_ids_in_student_path = group['module_id']\n for source_node, target_node in zip(module_ids_in_student_path[:-1], module_ids_in_student_path[1:]):\n if source_node != target_node: # stationary\n E[(source_node, target_node)] |= {user_id}\n\n for (source_node, target_node), students_that_made_transition in E.iteritems():\n G.add_edge(\n source_node,\n target_node,\n weight=len(students_that_made_transition))\n\n return G","def dijkstra(vs, es, s, stop = None):\n initialize_single_source(vs, es, s)\n key = lambda x: -1 * x._ss_d\n Q = pq(vs)\n edict = defaultdict(set)\n for e in es:\n edict[e.v1].add(e)\n edict[e.v2].add(e)\n\n for i in range(len(vs)):\n # min path to u is determined at end of loop\n u = Q.pop()\n for e in edict[u]:\n v = e.v1 if e.v1 != u else e.v2\n relax(u, v, e, Q)\n if u == stop: return \n \n result = [v._ss_d for v in vs]\n return result","def _load_flows(paths):\n assert isinstance(paths, list)\n # allocate memory\n flows = np.zeros([len(paths), FLAGS.target_height, FLAGS.target_width, 2],\n dtype=np.float32)\n\n # load all flows\n pbar = ProgressBar(max_value=len(paths)-1)\n for i in range(len(paths)):\n # Load flow\n flow = np.load(paths[i])\n\n # Central crop flow\n h, w, _ = flow.shape\n left = (w - FLAGS.target_width) // 2\n top = (h - FLAGS.target_height) // 2\n right = left + FLAGS.target_width\n bottom = top + FLAGS.target_height\n flow = flow[left:right, top:bottom, :]\n\n # Store flow\n flows[i] = flow\n pbar.update(i)\n return flows","def hash_flow(flow_5_tuple):\n ip_A = flow_5_tuple[0]\n ip_B = flow_5_tuple[1]\n tp_src = flow_5_tuple[2]\n tp_dst = flow_5_tuple[3]\n proto = flow_5_tuple[4]\n if proto == 6:\n #*** Is a TCP flow:\n if ip_A > ip_B:\n direction = 1\n elif ip_B > ip_A:\n direction = 2\n elif tp_src > tp_dst:\n direction = 1\n elif tp_dst > tp_src:\n direction = 2\n else:\n direction = 1\n else:\n #*** Isn't a flow, so arbitrarily set direction as 1:\n direction = 1\n if direction == 1:\n flow_tuple = (ip_A, ip_B, tp_src, tp_dst, proto)\n else:\n #*** Flip direction:\n flow_tuple = (ip_B, ip_A, tp_dst, tp_src, proto)\n return hash_tuple(flow_tuple)","def step(nodes, outputs, edges):\n flowed = []\n for node_name in nodes.copy():\n if node_name in flowed:\n continue\n if len(nodes[node_name]) == 2:\n if node_name in flowed:\n continue\n node = [int(value) for value in nodes[node_name]]\n low_value, high_value = min(node), max(node)\n low_flow, high_flow = edges[node_name] \n low_dictionary, low_node_name = low_flow\n high_dictionary, high_node_name = high_flow\n low_node = low_dictionary.get(low_node_name, tuple())\n high_node = high_dictionary.get(high_node_name, tuple())\n low_dictionary[low_node_name] = low_node + (str(low_value),)\n high_dictionary[high_node_name] = high_node + (str(high_value),)\n nodes[node_name] = tuple()\n if low_dictionary is nodes:\n flowed.append(low_node_name)\n if high_dictionary is nodes:\n flowed.append(high_node_name)\n return nodes, outputs, edges","def possible(self):\n return [tuple(path) for path in nx.all_shortest_paths(self._gpm.Graph, source=self.source, target=self.target)]","def bfs(self, s, visit=None):\n visited = set()\n\n # initialize the queue with the start vertex\n queue = deque([s])\n \n # loop until the queue is empty\n while queue:\n\n # get the next vertex\n v = queue.popleft()\n\n # skip it if it's already visited\n if v in visited: continue\n\n # mark it visited, then invoke the visit function\n visited.add(v)\n if visit: visit(v)\n\n # add its out vertices to the queue\n queue.extend(self.out_vertices(v))\n\n # return the visited vertices\n return visited","def get_all_pairs(G):\n # list all (start,dest) pairs between which the route must be computed\n pairs_list = [(start, dest) for dest in G.nodes for start in G.nodes]\n\n # shuffle all elements in-place\n random.shuffle(pairs_list)\n\n # generate a set from the list\n pairs_set = set(pairs_list)\n\n return pairs_list, pairs_set","def ListAllFlows(client_id: str) -> List[rdf_flow_objects.Flow]:\n return data_store.REL_DB.ReadAllFlowObjects(client_id=client_id)","def find_all_feedback_from_FVS(lt_links, ls_FVS=None):\n if not ls_FVS:\n set_nodes = set([])\n for t_link in lt_links:\n set_nodes.add(t_link[0])\n set_nodes.add(t_link[1])\n ls_FVS = FVS_analysis.FVS_finding(list(set_nodes), lt_links)[0]\n #if FVS nodes are already gained, pass this step\n \n llt_feedbacks = []\n dic_ts_FVSnodepair_llt_downstreams = {}#{(FVS node1, FVS node2):list of lt_downstream which starts at FVS node1 and ends at FVS node2}\n for s_FVSnode in ls_FVS:\n llt_downstreams = find_all_downstream_from_seed(lt_links, s_FVSnode, ls_FVS)\n for lt_downstream in llt_downstreams:\n ts_FVSpair = (s_FVSnode, lt_downstream[-1][-1])\n dic_ts_FVSnodepair_llt_downstreams.setdefault(ts_FVSpair,[]).append(lt_downstream)\n \n lts_cyclesofFVS = get_all_cycles(ls_FVS)\n for ts_cycleofFVS in lts_cyclesofFVS:\n if len(ts_cycleofFVS) == 1:\n llt_feedbacks.extend(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[0],ts_cycleofFVS[0])])\n else:\n b_stopflag = False\n lllt_feedbackfragment = []\n for i in range(len(ts_cycleofFVS)-1):\n lllt_feedbackfragment.append(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[i], ts_cycleofFVS[i+1])])\n if not dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[i], ts_cycleofFVS[i+1])]:\n b_stopflag = True\n break\n lllt_feedbackfragment.append(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[-1],ts_cycleofFVS[0])])\n if not dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[-1],ts_cycleofFVS[0])]:\n b_stopflag = True\n if b_stopflag:\n continue#if there is no feedback passing by all FVS nodes of that cycle, pass to next cycle\n \n llt_feedbacks_specific_cycle = lllt_feedbackfragment.pop(0)\n while lllt_feedbackfragment:\n llt_fragments_next = lllt_feedbackfragment.pop(0)\n llt_feedbacks_updated = []\n for lt_fragment in llt_feedbacks_specific_cycle:\n for lt_fragment_next in llt_fragments_next:\n ls_route = [t_link[1] for t_link in lt_fragment[:-1]]\n ls_route_next = [t_link[1] for t_link in lt_fragment_next[:-1]]\n if not set(ls_route).intersection(set(ls_route_next)):\n llt_feedbacks_updated.append(lt_fragment+lt_fragment_next)\n llt_feedbacks_specific_cycle = llt_feedbacks_updated\n llt_feedbacks.extend(llt_feedbacks_specific_cycle)\n\n return llt_feedbacks","def run_destination_reduction(self):\n s = self.sources\n t = self.destinations\n\n # get the union set of source edges\n s_edges = [self.out_edges(x) for x in s]\n s_edges_idx = [set(self.get_edges_indices(src)) for src in s_edges]\n S = set.union(*s_edges_idx)\n\n # now starting from the sources\n T_curr = [set(self.in_edges(x)) for x in t]\n T_curr_idx = [set(self.get_edges_indices(x)) for x in T_curr]\n T_union = set.union(*[set(x) for x in T_curr])\n T_union_idx = set.union(*T_curr_idx)\n self.dst_evolution_rec = [T_curr_idx]\n\n while not T_union_idx.issubset(S):\n # get the edges out of the max-ordered node\n tail_nodes = set([x[0] for x in T_union])\n tail_nodes = tail_nodes - set(s)\n v = max(tail_nodes, key=lambda p: self.node[p]['index'])\n\n E = set([edge for edge in T_union if edge[0] == v])\n E_curr = [x.intersection(E) for x in T_curr]\n\n T_next = []\n Uv = self.in_edges(v)\n for (Ex, Tx) in zip(E_curr, T_curr):\n if Ex:\n T_next.append((Tx - Ex).union(Uv))\n else:\n T_next.append(Tx)\n\n T_curr = T_next\n T_curr_idx = [set(self.get_edges_indices(x)) for x in T_curr]\n self.dst_evolution_rec.append(T_curr_idx)\n\n T_union = set.union(*[set(x) for x in T_curr])\n T_union_idx = set.union(*T_curr_idx)","def min_path(vs, es, source, target):\n dijkstra(vs, es, source, stop = target)\n test = target\n result = []\n while test != source:\n e = test._ss_edge\n result.append(e)\n test = e.v1 if e.v1 != test else e.v2\n assert test == source and test._ss_edge is None\n return result[::-1]","def get_bfs(self, s):\n # create a queue for BFS\n queue = []\n # mark all the vertices as not visited\n visited = [False] * (len(self.graph))\n # mark the start node as visited and enqueue it\n visited[s] = True\n queue.append(s)\n results = []\n\n while queue:\n # dequeue a vertex from queue and append to results.\n p = queue.pop(0)\n results.append(p)\n # get all adjacent vertices of the dequeued vertex s,\n # and for any unvisited adjacent, mark it visited and enqueue it.\n for v in self.graph[p]:\n if visited[v] is False:\n visited[v] = True\n queue.append(v)\n\n return results","def get_flows(self, num_flows_per_entry):\n flows = []\n for tenant in self._tenants:\n for contract in tenant.get_children(only_class=Contract):\n providing_epgs = contract.get_all_providing_epgs()\n consuming_epgs = contract.get_all_consuming_epgs()\n for providing_epg in providing_epgs:\n vlan_ifs = providing_epg.get_all_attached(L2Interface)\n if len(vlan_ifs):\n providing_vlan = vlan_ifs[0].encap_id\n phys_ifs = vlan_ifs[0].get_all_attached(Interface)\n if len(phys_ifs):\n providing_phys_if = phys_ifs[0].name\n for consuming_epg in consuming_epgs:\n vlan_ifs = consuming_epg.get_all_attached(L2Interface)\n if len(vlan_ifs):\n consuming_vlan = vlan_ifs[0].encap_id\n phys_ifs = vlan_ifs[0].get_all_attached(Interface)\n if len(phys_ifs):\n consuming_phys_if = phys_ifs[0].name\n if providing_vlan == consuming_vlan and providing_phys_if == consuming_phys_if:\n # Skip this case since traffic would be switched outside fabric\n continue\n for filter_entry in contract.get_all_filter_entries():\n for i in range(0, num_flows_per_entry):\n flow = Flow()\n flow.ethertype = filter_entry.etherT\n if flow.ethertype == 'arp':\n flow.arp_opcode = filter_entry.arpOpc\n flow.populate_random_ip_addresses()\n elif flow.ethertype == 'ip':\n flow.populate_random_ip_addresses()\n flow.proto = filter_entry.prot\n if flow.proto == '6' or flow.proto == '17':\n dFromPort = int(filter_entry.dFromPort)\n dToPort = int(filter_entry.dToPort)\n sFromPort = int(filter_entry.sFromPort)\n sToPort = int(filter_entry.sToPort)\n if dFromPort == 0:\n dFromPort = 1\n dToPort += 1\n if sFromPort == 0:\n sFromPort = 1\n sToPort += 1\n if dToPort > 65534:\n dToPort = 65534\n if sToPort > 65534:\n sToPort = 65534\n flow.dport = str(random_number(dFromPort,\n dToPort))\n flow.sport = str(random_number(sFromPort,\n sToPort))\n if flow.proto == '6':\n flow.tcp_rules = filter_entry.tcpRules\n flow.svlan = providing_vlan\n flow.dvlan = consuming_vlan\n flow.src_intf = providing_phys_if\n flow.dst_intf = consuming_phys_if\n\n # Is the flow expected to succeed ?\n flow.expected_action = 'drop'\n providing_bd = providing_epg.get_bd()\n consuming_bd = consuming_epg.get_bd()\n if providing_bd and consuming_bd:\n if providing_bd == consuming_bd:\n if providing_bd.get_context() == consuming_bd.get_context():\n flow.expected_action = 'permit'\n flow.populate_random_mac_addresses()\n flows.append(flow)\n return flows","def _ism_get_mirror_sources(source, receiver, walls, order_threshold, mirrors_threshold):\n logger.info(\"_ism_get_mirror_sources: Determining mirror sources.\")\n model = ism.Model(walls=walls, source=source, receiver=receiver, max_order=order_threshold)\n mirrors = model.determine(strongest=mirrors_threshold)\n yield from mirrors","def generate_graph(size, number_of_clusters, minimal_size):\n base_list = list(range(size))\n result_list = []\n random.shuffle(base_list)\n for i in range(number_of_clusters - 1):\n size = random.randint(minimal_size, len(base_list) - (number_of_clusters - i - 1) * minimal_size)\n cluster = []\n for n in range(size):\n actual = random.choice(base_list)\n base_list.remove(actual)\n cluster.append(actual)\n result_list.append(strongly_connect(cluster))\n result_list.append(strongly_connect(base_list))\n\n while len(result_list) < 5:\n result_list.append([])\n\n print(sorted([len(i) for i in result_list], reverse=True)[:5])\n\n return weak_connect_graph(result_list)","def generateNumsets(G):\n # paths = []\n #\n # path = [0]\n # for edge in nx.dfs_edges(G, 0):\n # if edge[0] == path[-1]:\n # path.append(edge[1])\n # else:\n # paths.append(path)\n # search_index = 2\n # while search_index <= len(path):\n # if edge[0] == path[-search_index]:\n # path = path[:-search_index + 1] + [edge[1]]\n # break\n # search_index += 1\n # else:\n # raise Exception(\"Wrong path structure?\", path, edge)\n # paths.append(path)\n # return paths\n\n \"\"\"\n Trying to use itertools LMAO\n \"\"\"\n # paths = []\n #\n # for path in itertools.combinations(G.nodes, 5):\n # paths.append(path)\n # return paths\n\n \"\"\"\n Generating paths using graph\n \"\"\"\n paths = []\n n = len(G.nodes)\n for source in range(n):\n for target in range(source+1, n):\n paths.extend([path for path in nx.all_simple_paths(G, source=source, target=target)])\n return paths\n\n # return paths","def objective(graph, flows):\n\n G = graph.copy()\n rules = {}\n flows.sort(key=lambda a: a[1], reverse=True)\n\n for flow,demand in flows:\n src = get_host_from_ip(G, flow.nw_src)\n dst = get_host_from_ip(G, flow.nw_dst)\n\n if not (src and dst):\n continue\n if not (src in G.nodes() and dst in G.nodes()):\n continue\n\n path = widest_path(G, src, dst)\n\n hops = []\n for a,b in pairwise(path):\n hops.append(Hop(dpid=int(a[1:]), port=G.edge[a][b]['port']))\n G.edge[a][b]['capacity'] -= demand\n G.edge[b][a]['capacity'] -= demand\n\n rules[flow] = hops\n\n return rules","def __generate_all_shortest_paths(self,cutoff = 10):\n if cutoff < 1:\n cutoff = 10\n self.__logger.info(\"cutoff value must be a positive integer. Set back to default value: 10\")\n\n all_pair_shortest_paths = nx.all_pairs_shortest_path(self.G, cutoff=cutoff)\n for item in all_pair_shortest_paths:\n from_node = item[0]\n paths = item[1]\n for destination,path in paths.items():\n yield (len(path),path)","def compute_flow(self, lqs):\n n, t, c, h, w = lqs.size()\n lqs_1 = lqs[:, :-1, :, :, :].reshape(-1, c, h, w)\n lqs_2 = lqs[:, 1:, :, :, :].reshape(-1, c, h, w)\n flows_backward = self.spynet(lqs_1, lqs_2).view(n, t - 1, 2, h, w)\n if self.is_mirror_extended:\n flows_forward = None\n else:\n flows_forward = self.spynet(lqs_2, lqs_1).view(n, t - 1, 2, h, w)\n return flows_forward, flows_backward","def bfs (graph, src, tgt):\n\n if not graph.has_key(src):\n raise AttributeError(\"The source '%s' is not in the graph\" % src)\n if not graph.has_key(tgt):\n raise AttributeError(\"The target '%s' is not in the graph\" % tgt)\n\n parents = {src: None}\n queue = deque([src])\n while queue:\n node = queue.popleft()\n for neighbor in graph[node]:\n if neighbor not in parents:\n parents[neighbor] = node\n queue.append(neighbor)\n if node == tgt:\n break\n\n path = [tgt]\n while parents[tgt] is not None:\n path.insert(0, parents[tgt])\n tgt = parents[tgt]\n\n return path","def bfs(self, s):\n g = Graph(attr={DIRECTED: True})\n root = self.get_vertex(s)\n root.attributes[DISCOVERED] = True\n q = collections.deque()\n adjacent_type = '+' if DIRECTED in self.attr and self.attr[\n DIRECTED] else None\n # Insert root node in graph and queue\n g.add_vertex(root)\n q.append(s)\n\n while (len(q) > 0):\n v = q.popleft()\n for e in self.get_adjacent_vertices_by_vertex(v, adjacent_type):\n w = self.get_vertex(e)\n if DISCOVERED not in w.attributes or w.attributes[\n DISCOVERED] is False:\n w.attributes[DISCOVERED] = True\n q.append(w.id)\n g.add_vertex(w)\n g.add_edge(edge.Edge(v, e), True)\n return g","def _dfs(\n self, kg: KG, entity: Vertex, is_reverse: bool = False\n ) -> List[Walk]:\n self.sampler.visited = set()\n walks: List[Walk] = []\n assert self.max_walks is not None\n\n rng = np.random.RandomState(self.random_state)\n\n while len(walks) < self.max_walks:\n sub_walk: Walk = (entity,)\n d = 1\n while d // 2 < self.max_depth:\n pred_obj = self.sampler.sample_hop(\n kg, sub_walk, d // 2 == self.max_depth - 1, is_reverse\n )\n if pred_obj is None:\n break\n\n if is_reverse:\n if (\n pred_obj[0] in self.communities\n and rng.random() < self.hop_prob\n ):\n community_nodes = self.labels_per_community[\n self.communities[pred_obj[0]]\n ]\n sub_walk = (\n pred_obj[1],\n rng.choice(community_nodes),\n ) + sub_walk\n else:\n sub_walk = (pred_obj[1], pred_obj[0]) + sub_walk\n else:\n if (\n pred_obj[1] in self.communities\n and rng.random() < self.hop_prob\n ):\n community_nodes = self.labels_per_community[\n self.communities[pred_obj[1]]\n ]\n sub_walk += (\n pred_obj[0],\n rng.choice(community_nodes),\n )\n else:\n sub_walk += (pred_obj[0], pred_obj[1])\n d = len(sub_walk) - 1\n walks.append(sub_walk)\n return list(walks)","def sinks(self):\n s = [node for node in self.nodes() if node.isSink()]\n s.sort(lambda x,y: cmp(x._id, y._id))\n return s","def get_all_sghop_info (nffg, return_paths=False):\n sg_map = {}\n for i in nffg.infras:\n for p in i.ports:\n for fr in p.flowrules:\n # if fr.external:\n # continue\n if fr.id not in sg_map:\n # The path is unordered!!\n path_of_shop = []\n flowclass = NFFGToolBox._extract_flowclass(fr.match.split(\";\"))\n sg_map[fr.id] = [None, None, flowclass, fr.bandwidth, fr.delay]\n # We have to find the BEGINNING of this flowrule sequence.\n inbound_link = NFFGToolBox._find_infra_link(nffg, p, outbound=False,\n accept_dyn=True)\n while inbound_link.type != 'DYNAMIC':\n path_of_shop.append(inbound_link)\n if inbound_link.src.node.type == 'SAP':\n break\n # The link is STATIC, and its src is not SAP so it is an Infra.\n prev_fr, prev_p = \\\n NFFGToolBox._get_flowrule_and_its_starting_port(\n inbound_link.src.node, fr.id)\n NFFGToolBox._check_flow_consistencity(sg_map, prev_fr)\n inbound_link = NFFGToolBox._find_infra_link(nffg, prev_p,\n outbound=False,\n accept_dyn=True)\n # 'inbound_link' is DYNAMIC here or it is STATIC and starts from\n # a SAP,\n # so the sequence starts here\n sg_map[fr.id][0] = inbound_link.src\n\n # We have to find the ENDING of this flowrule sequence.\n output_port = NFFGToolBox._get_output_port_of_flowrule(i, fr)\n if output_port is None:\n continue\n outbound_link = NFFGToolBox._find_infra_link(nffg, output_port,\n outbound=True,\n accept_dyn=True)\n while outbound_link.type != 'DYNAMIC':\n path_of_shop.append(outbound_link)\n if outbound_link.dst.node.type == 'SAP':\n break\n # The link is STATIC and its dst is not a SAP so it is an Infra.\n next_fr, _ = NFFGToolBox._get_flowrule_and_its_starting_port(\n outbound_link.dst.node, fr.id)\n # '_' is 'outbound_link.dst'\n next_output_port = NFFGToolBox._get_output_port_of_flowrule(\n outbound_link.dst.node, next_fr)\n NFFGToolBox._check_flow_consistencity(sg_map, next_fr)\n outbound_link = NFFGToolBox._find_infra_link(nffg,\n next_output_port,\n outbound=True,\n accept_dyn=True)\n # the 'outbound_link' is DYNAMIC here or finishes in a SAP, so the\n # flowrule sequence finished here.\n sg_map[fr.id][1] = outbound_link.dst\n\n if return_paths:\n sg_map[fr.id].append(path_of_shop)\n\n return sg_map","def ECMPBFS(self, flow, edge_mark):\n\t\t# Distance flag for each node\n\t\td = {v:float('inf') for v in self.topo.nodes}\n\t\t# Parent node for each node\n\t\tpa = {v:[] for v in self.topo.nodes}\n\t\t# Request info\n\t\ts = flow[0]\n\t\tt = flow[1]\n\n\t\t# BFS to find a min-hop path\n\t\tqueue = [s]; hdr = 0; d[s] = 0\n\t\twhile hdr < len(queue):\n\t\t\tu = queue[hdr]\n\t\t\thdr += 1\n\n\t\t\tfor v in self.topo.topo.neighbors(u):\t# This is directed neighbors in the context\n\t\t\t\tif edge_mark[(u, v)] or d[v] < d[u] + 1:\n\t\t\t\t\tcontinue\n\t\t\t\tif d[v] > d[u] + 1:\n\t\t\t\t\tqueue.append(v)\n\t\t\t\t\tpa[v] = [u]\n\t\t\t\telif d[v] == d[u] + 1:\n\t\t\t\t\tpa[v].append(u)\n\t\t\t\td[v] = d[u] + 1\n\n\t\tif d[t] == float('inf'):\n\t\t\treturn False\n\n\t\t# Iteratively find all paths until there is no\n\t\tp_lst = []\n\t\twhile True:\n\t\t\tp = [t]; v = t; branch = None; branch_idx = None\n\t\t\twhile v != s and v != -1:\n\t\t\t\tif len(pa[v]) > 0:\n\t\t\t\t\tif pa[v] > 1:\n\t\t\t\t\t\tbranch = v\n\t\t\t\t\t\tbranch_idx = 0\n\t\t\t\t\tv = pa[v][0]\n\t\t\t\t\tp.append(v)\n\t\t\t\telse:\n\t\t\t\t\tbreak\n\t\t\tif v == s:\n\t\t\t\tp.reverse()\n\t\t\t\tp_lst.append(p)\n\t\t\telse:\n\t\t\t\tbreak\n\t\t\tif branch:\n\t\t\t\tpa[branch].pop(branch_idx)\n\n\t\treturn p_lst","def get_flow_4frames(self, flows_forward, flows_backward):\n d = flows_forward[0].shape[1]\n flows_backward2 = []\n for flows in flows_backward:\n flow_list = []\n for i in range(d - 1, 0, -1):\n flow_n1 = flows[:, i - 1, :, :, :]\n flow_n2 = flows[:, i, :, :, :]\n flow_list.insert(0, flow_n1 + flow_warp(flow_n2, flow_n1.permute(0, 2, 3, 1)))\n flows_backward2.append(torch.stack(flow_list, 1))\n flows_forward2 = []\n for flows in flows_forward:\n flow_list = []\n for i in range(1, d):\n flow_n1 = flows[:, i, :, :, :]\n flow_n2 = flows[:, i - 1, :, :, :]\n flow_list.append(flow_n1 + flow_warp(flow_n2, flow_n1.permute(0, 2, 3, 1)))\n flows_forward2.append(torch.stack(flow_list, 1))\n return flows_backward2, flows_forward2","def gen_flow_session(self, set_choice, seq_len):\r\n return_seq = []\r\n chosen_set = self.split_flow[set_choice]\r\n\r\n for poi_index, group in chosen_set.groupby('poi_index'):\r\n for i in range(group.shape[0] - seq_len + 1):\r\n flow_seq = group['flow'].iloc[i:i+seq_len]\r\n if flow_seq.sum() > 0:\r\n return_seq.append([poi_index, flow_seq.to_list()])\r\n return return_seq","def showFlow(self):\r\n def edgesFromVertex(u):\r\n \"\"\"\r\n Represents the flow across the given vertex.\r\n \"\"\"\r\n edgeRepresentation = lambda v: f\"({u}, {v}, {self.getCapacity((u, v))}, {self.getFlow((u,v))})\"\r\n return \", \".join(map(edgeRepresentation, sorted(self.adjacent[u])))\r\n\r\n def adjacencyLists():\r\n \"\"\"\r\n Represents the flow across all relevant vertices.\r\n \"\"\"\r\n anyNeighbor = lambda u: any(self.neighbors(u))\r\n verticesWithNeighbors = filter(anyNeighbor, sorted(self.vertices()))\r\n return map(edgesFromVertex, verticesWithNeighbors)\r\n\r\n return print(\"\\n\".join(adjacencyLists()))","def calc_lp(self, demands: Demand, routing: Routing) -> float:\n epsilon = self.epsilon\n\n # Create the linear solver with the GLOP backend.\n solver = pywraplp.Solver('flow_utilisation_lp',\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\n\n ## VARIABLES\n # Flow variables, the amount of flow along each edge\n # stored as a list flow_variables[ith_flow][jth_edge]\n flow_variables = []\n for i in range(len(self.commodities)):\n flow_variable_edges = []\n for j in range(len(self.edges)):\n flow_variable_edges.append(\n solver.NumVar(0, solver.infinity(), '({},{})'.format(i, j)))\n flow_variables.append(flow_variable_edges)\n\n ## CONSTRAINTS\n # Flow from source constraint (net flow must equal demand)\n conservation_source_constraints = []\n for i, commodity in enumerate(self.commodities):\n # create constraint\n constraint_i = solver.Constraint(demands[i] - epsilon,\n demands[i] + epsilon,\n '(source,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[0])]:\n # out flow is positive\n constraint_i.SetCoefficient(flow_variables[i][edge_index], 1)\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[0])]:\n # in flow is negative\n constraint_i.SetCoefficient(flow_variables[i][edge_index], -1)\n conservation_source_constraints.append(constraint_i)\n\n # Flow to sink constraint (in flow must equal demand, out must be zero)\n conservation_sink_constraints = []\n for i, commodity in enumerate(self.commodities):\n # create in flow constraint\n constraint_i_in = solver.Constraint(-demands[i] - epsilon,\n -demands[i] + epsilon,\n '(sink_in,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[1])]:\n # in flow is negative\n constraint_i_in.SetCoefficient(flow_variables[i][edge_index],\n -1)\n conservation_sink_constraints.append(constraint_i_in)\n\n constraint_i_out = solver.Constraint(0, 0,\n '(sink_out,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[1])]:\n # out flow is positive\n constraint_i_out.SetCoefficient(flow_variables[i][edge_index],\n 1)\n conservation_sink_constraints.append(constraint_i_out)\n\n # Flow at transit node constraint (net flow must be zero)\n conservation_transit_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.graph.number_of_nodes()):\n if j != commodity[0] and j != commodity[1]:\n # create constraint\n constraint_j = solver.Constraint(-epsilon, +epsilon,\n '(transit,{},{})'.format(i,\n j))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(j)]:\n # out flow is positive\n constraint_j.SetCoefficient(\n flow_variables[i][edge_index],\n 1)\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(j)]:\n # in flow is negative\n constraint_j.SetCoefficient(\n flow_variables[i][edge_index],\n -1)\n constraints_flow_i.append(constraint_j)\n conservation_transit_constraints.append(constraints_flow_i)\n\n # Flow splitting at transit constraints (edge flow must be correct split of\n # in flow)\n splitting_ratio_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.graph.number_of_nodes()):\n # Sink has not such constraint and we handle source differently\n if j != commodity[1] and j != commodity[0]:\n in_edges = [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(j)]\n out_edges = [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(j)]\n\n # separate constraint for split of each out_edge taking into\n # account all in_edges\n for out_edge_index in out_edges:\n # create constraint\n constraint_edge = \\\n solver.Constraint(-epsilon, +epsilon,\n '(split,{},{},{})'.format(\n i, j,\n out_edge_index))\n split_ratio = routing[i][out_edge_index]\n # flow on out edge\n constraint_edge.SetCoefficient(\n flow_variables[i][out_edge_index], 1)\n for in_edge_index in in_edges:\n # should equal sum of flow on all in edges scaled by\n # split ratio\n constraint_edge.SetCoefficient(\n flow_variables[i][in_edge_index],\n -1 * split_ratio)\n constraints_flow_i.append(constraint_edge)\n splitting_ratio_constraints.append(constraints_flow_i)\n\n # Flow splitting at source constraints (edge flow must be correct split of\n # in flow + demand)\n source_splitting_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n in_edges = [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[0])]\n out_edges = [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[0])]\n for out_edge_index in out_edges:\n # create constraint\n split_ratio = routing[i][out_edge_index]\n split_demand = split_ratio * demands[i]\n constraint_edge = \\\n solver.Constraint(split_demand - epsilon,\n split_demand + epsilon,\n '(split,{},{},{})'.format(i, j,\n out_edge_index))\n # flow on out edge\n constraint_edge.SetCoefficient(\n flow_variables[i][out_edge_index], 1)\n for in_edge_index in in_edges:\n # should equal sum of flow on all in edges scaled by split ratio\n constraint_edge.SetCoefficient(\n flow_variables[i][in_edge_index],\n -1 * split_ratio)\n constraints_flow_i.append(constraint_edge)\n source_splitting_constraints.append(constraints_flow_i)\n\n solver.Solve()\n\n result_status = solver.Solve()\n\n utilisation = np.zeros(\n (len(self.commodities), self.graph.number_of_edges()))\n # # extract the actual routing. Useful for debugging, maybe use to bootstrap\n # assignment = np.zeros(\n # (len(self.commodities), self.graph.number_of_edges()))\n\n # if routing is really that bad, just bail and give a sad result\n if result_status == solver.NOT_SOLVED or result_status == solver.INFEASIBLE:\n return 1.0\n\n for i in range(len(self.commodities)):\n for j in range(self.graph.number_of_edges()):\n utilisation[i][j] = flow_variables[i][j].solution_value() / \\\n self.edges[j][2]['weight']\n # assignment[i][j] = flow_variables[i][j].solution_value()\n\n return np.max(np.sum(utilisation, axis=0))","def dijkstra_tree(self, s):\n l = []\n dist = {}\n prev = {}\n discovered = {}\n g = Graph(attr={DIRECTED: True})\n g.add_vertex(vertex.Vertex(s, {\"WEIGHT\": 0}))\n for v in self.get_vertices():\n dist[v] = float('inf')\n prev[v] = None\n discovered[v] = False\n dist[s] = 0\n l.append((s, dist[s]))\n while len(l) != 0:\n u = min(l, key=lambda x: x[1])\n l.remove(u)\n u = u[0]\n discovered[u] = True\n for v in self.get_adjacent_vertices_by_vertex(u):\n if not discovered[v]:\n alt = dist[u] + self.get_edge((u, v)).attr[\"WEIGHT\"]\n if alt < dist[v]:\n dist[v] = alt\n prev[v] = u\n l.append((v, dist[v]))\n g.add_vertex(vertex.Vertex(v, {\"WEIGHT\": dist[v]}))\n g.add_edge(edge.Edge(u, v, {\"WEIGHT\": dist[v]}))\n\n return g","def _get_allow_all_flows() -> List[FlowDescription]:\n return [\n # Set flow match for all packets\n # Don't set the app_name field\n FlowDescription( # uplink flow\n match=FlowMatch(\n direction=FlowMatch.Direction.Value(\"UPLINK\"),\n ),\n action=FlowDescription.Action.Value(\"PERMIT\"),\n ),\n FlowDescription( # downlink flow\n match=FlowMatch(\n direction=FlowMatch.Direction.Value(\"DOWNLINK\"),\n ),\n action=FlowDescription.Action.Value(\"PERMIT\"),\n ),\n ]","def generate(\n self,\n num_nodes_src_set: int,\n num_nodes_dst_set: int,\n num_edges_src_dst: int,\n num_edges_dst_src: int,\n is_directed: bool,\n return_node_ids: bool = False,\n transform_graph: bool = True,\n *args,\n **kwargs,\n ):\n raise NotImplementedError()","def _pfs_nodes(cls, graph, source, size, priority):\n if size < 1:\n return iter(())\n\n # use min-heap to implement (max) priority queue\n # use insertion order to break priority tie\n queue = []\n counter = itertools.count()\n push = lambda priority, node: heappush(queue, (-priority, next(counter), node))\n pop = partial(heappop, queue)\n\n visited = set()\n enqueued = set()\n push(priority(source), source)\n\n while queue and len(visited) < size:\n _, _, node = pop()\n\n if node in visited:\n continue\n\n visited.add(node)\n\n for neighbor in graph[node]:\n if neighbor not in enqueued:\n enqueued.add(neighbor)\n push(priority(neighbor), neighbor)\n\n return iter(visited)","def stochastic_event_set(\n sources, source_site_filter=filters.source_site_noop_filter):\n for source, s_sites in source_site_filter(sources):\n try:\n for rupture in source.iter_ruptures():\n for i in range(rupture.sample_number_of_occurrences()):\n yield rupture\n except Exception as err:\n etype, err, tb = sys.exc_info()\n msg = 'An error occurred with source id=%s. Error: %s'\n msg %= (source.source_id, str(err))\n raise_(etype, msg, tb)","def get_flows(self, x):\n if self.pa_frames == 2:\n flows_backward, flows_forward = self.get_flow_2frames(x)\n elif self.pa_frames == 4:\n flows_backward_2frames, flows_forward_2frames = self.get_flow_2frames(x)\n flows_backward_4frames, flows_forward_4frames = self.get_flow_4frames(flows_forward_2frames, flows_backward_2frames)\n flows_backward = flows_backward_2frames + flows_backward_4frames\n flows_forward = flows_forward_2frames + flows_forward_4frames\n elif self.pa_frames == 6:\n flows_backward_2frames, flows_forward_2frames = self.get_flow_2frames(x)\n flows_backward_4frames, flows_forward_4frames = self.get_flow_4frames(flows_forward_2frames, flows_backward_2frames)\n flows_backward_6frames, flows_forward_6frames = self.get_flow_6frames(flows_forward_2frames, flows_backward_2frames, flows_forward_4frames, flows_backward_4frames)\n flows_backward = flows_backward_2frames + flows_backward_4frames + flows_backward_6frames\n flows_forward = flows_forward_2frames + flows_forward_4frames + flows_forward_6frames\n return flows_backward, flows_forward","def ssf(n, N_max = 6, E_max = 4, time_total = 100 ):\n\n G = nx.DiGraph()\n G.add_edge( 0, 1, time_stamp = 1)\n\n # List of existing nodes, with nodes repeated once for each adjacent edge\n repeated_nodes = [0, 1]\n\n # compute discrete bins for nodes \n DistNodes = _get_distribution( N_max, 0 )\n # compute discrete bins for edges\n DistLinks = _get_distribution( E_max, 1 )\n \n # Start adding the other n - 2 nodes.\n N_current = time_current = 2\n while N_current < n and time_current < time_total + 1:\n # preferential attachment\n N_current = _preferential_attachment( DistNodes, DistLinks, N_current,\n time_total, time_current, n, repeated_nodes, G )\n time_current += 1\n \n# print(time_current, N_current)\n return G","def get_all_network_graphs(list_mtfs):\n list_graphs = []\n \n for mtf in list_mtfs:\n list_graphs.append(get_network_graph(mtf))\n \n return list_graphs","def sources(self):\n if self.rank < self.midpoint:\n partner = self.midpoint + (self.rank - self.left)\n if self.rank == self.midpoint - 1 and partner == self.right:\n partners = set()\n elif self.rank == self.midpoint - 1 and partner == self.right - 2:\n partners = {partner, partner + 1}\n else:\n partners = {partner}\n else:\n partner = self.left + (self.rank - self.midpoint)\n if self.rank == self.right - 1 and partner == self.midpoint:\n partners = set()\n elif self.rank == self.right - 1 and partner == self.midpoint - 2:\n partners = {partner, partner + 1}\n else:\n partners = {partner}\n\n return partners","def update_flow(self):\n N = len(self.vertices)\n _vertices = self.vertices+['_source', '_sink']\n s, t = _vertices.index('_source'), _vertices.index('_sink')\n cost, capacity = dok_matrix((N+2, N+2)), dok_matrix((N+2, N+2))\n\n cost[:N, :N] = self.cost\n capacity[:N, :N] = self.upper_bound-self.lower_bound\n # _source to main vertices\n l_in = self.lower_bound.toarray().sum(axis=0)\n us, = l_in.nonzero()\n for u in us:\n capacity[s, u] = l_in[u]\n # main vertices to _sink\n l_out = self.lower_bound.toarray().sum(axis=1)\n us, = l_out.nonzero()\n for u in us:\n capacity[u, t] = l_out[u]\n # sink to source\n infinite_flow = self.upper_bound.toarray().sum()\n capacity[_vertices.index('sink'), _vertices.index('source')] = infinite_flow\n\n # get a feasible flow on original graph by finding the max flow on\n # auxiliary graph\n aux_fg = FlowGraph(_vertices, cost, capacity, True)\n aux_fg.FordFulkerson()\n assert aux_fg.residual[s].toarray().sum()==0, 'feasible flow within bounds not found'\n\n self.residual = aux_fg.residual[:N, :N]\n s, t = self.vertices.index('source'), self.vertices.index('sink')\n self.residual[s, t] = 0\n self.residual[t, s] = 0\n\n self.FordFulkerson()","def bfs(graph, source):\n visited = [False] * len(graph.graph)\n print(visited)\n\n result = \"\"\n queue = []\n\n queue.append(source)\n visited[source] = True\n\n while queue:\n source = queue.pop(0)\n result += str(source)\n\n while graph.graph[source] is not None:\n data = graph.graph[source].vertex\n if not visited[data]:\n queue.append(data)\n visited[data] = True\n graph.graph[source] = graph.graph[source].next\n return result","def multipleTravellingSalesmen(self, iterations=None):\n if not iterations:\n iterations = self.mTSPIterations\n\n # Randomly select points drawn from unvisited and distribute equally among the ships\n paths = self.partition(self.unvisited.keys(), len(self.ships))\n [path.append(ship) for path, ship in zip(paths, self.ships)]\n\n # Run single travelling salesman on each of the ships\n paths = [self.singleTravellingSalesman(path, iterations=0) for path in paths]\n\n\n # IF TWO OR MORE SHIPS!!!\n # Point exchange between ships and rerun tsp on each ship\n if len(self.ships) > 1:\n for _ in range(iterations):\n twopathindices = random.sample(xrange(len(paths)), 2)\n newtwopaths = self.swapTwoPointsBetweenPaths([paths[index] for index in twopathindices])\n newtwopaths = [self.singleTravellingSalesman(path, iterations=max(len(path), 100)) for path in\n newtwopaths]\n if self.totalPathDistance(newtwopaths) < self.totalPathDistance(\n [paths[index] for index in twopathindices]):\n for i, index in enumerate(twopathindices):\n paths[index] = newtwopaths[i]\n\n return paths","def sg_hops (self):\n return (link for s, d, link in self.network.edges_iter(data=True) if\n link.type == Link.SG)","def _bfs_nodes(cls, graph, source, size, **kwargs):\n if size < 1:\n return iter(())\n\n return itertools.chain(\n (source,),\n itertools.islice((v for u, v in nx.bfs_edges(graph, source)), size-1)\n )","def find_all_cycles(s,graph):\n\n grph = u.edge_to_list_dict(graph)\n node_cnt = len(grph)\n k = z.Int(\"k\")\n syms = [z.Int('node%s'%i) for i in range(node_cnt)]\n\n # s.add(syms[0] == 0) # start node is a 0\n s.add(k < node_cnt)\n s.add(k > 1)\n\n o = z.Optimize()\n\n # for source, sinks in sgraph.s_adj_list():\n for i in range(node_cnt):\n s.add(syms[i] >= 0)\n s.add(syms[i] <= k)\n s.add(z.Or([syms[j] == ((syms[i] + 1) % k) for j in grph[i]]) == (syms[i] == 0))\n\n\n r = []\n m = []\n\n # o.minimize(z.Sum([syms[i] for i in range(node_cnt)]))\n s.add(z.Product([syms[i] for i in range(node_cnt)]) == 0)\n done = False\n while not done:\n if s.check() == z.sat:\n m = s.model()\n r.append(m)\n s.add(k != m[k])\n else:\n done = True\n\n return r","def get_weight_from_minflow(self):\n start_nodes = []\n end_nodes = []\n capacities = []\n unit_costs = []\n A = 0\n s_prime = self.sink() + 1\n t_prime = self.sink() + 2\n x = self.sink() + 3\n # for every edge in the graph, add edge to mincost flow instance with\n # infinite capacity and cost 1\n # also add backwards edge\n for arc in self.arc_info.keys():\n # forward edge\n start_nodes.append(self.arc_info[arc][\"start\"])\n end_nodes.append(self.arc_info[arc][\"destin\"])\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"start\"],\n self.arc_info[arc][\"destin\"]))\n # backward edge\n start_nodes.append(self.arc_info[arc][\"destin\"])\n end_nodes.append(self.arc_info[arc][\"start\"])\n capacities.append(int(self.arc_info[arc][\"weight\"])) # no negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"destin\"],\n self.arc_info[arc][\"start\"]))\n # add (x,s) and (t,x) edges with same cap, cost as above\n in_weight_x = 0\n for in_arc in self.in_arcs_lists[self.sink()]:\n in_weight_x += self.arc_info[in_arc][\"weight\"]\n out_weight_x = 0\n for out_arc in self.out_arcs_lists[self.source()]:\n out_weight_x += self.arc_info[out_arc][\"weight\"]\n # (x,s)\n start_nodes.append(x)\n end_nodes.append(self.source())\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.source()))\n # backward\n start_nodes.append(self.source())\n end_nodes.append(x)\n capacities.append(int(out_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.source(),\n x))\n # (t,x)\n start_nodes.append(self.sink())\n end_nodes.append(x)\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.sink(),\n x))\n # backward\n start_nodes.append(x)\n end_nodes.append(self.sink())\n capacities.append(int(in_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.sink()))\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\n # and cost 0.\n for v in self:\n # process internal verts only, since we assume source and sink have\n # no in and out edges respectively\n if v != self.source() and v != self.sink():\n # compute a-exc(v)\n in_weight = 0\n for in_arc in self.in_arcs_lists[v]:\n in_weight += self.arc_info[in_arc][\"weight\"]\n out_weight = 0\n for out_arc in self.out_arcs_lists[v]:\n out_weight += self.arc_info[out_arc][\"weight\"]\n a_exc = out_weight - in_weight\n if a_exc < 0:\n # add edge (s', v)\n start_nodes.append(s_prime)\n end_nodes.append(v)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n v,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (v, t')\n start_nodes.append(v)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n v,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # process x node\n a_exc = out_weight_x - in_weight_x\n if a_exc < 0:\n # add edge (s', x)\n start_nodes.append(s_prime)\n end_nodes.append(x)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n x,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (x, t')\n start_nodes.append(x)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n x,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # we must send flow of A from s_prime to t_prime\n supplies = [0]*(len(self) + 3)\n supplies[s_prime] = int(A)\n supplies[t_prime] = int(-A)\n # Instantiate a SimpleMinCostFlow solver.\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\n # Add each arc.\n for i in range(len(start_nodes)):\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\n end_nodes[i], capacities[i], unit_costs[i])\n # Add node supplies\n for i in range(0, len(supplies)):\n min_cost_flow.SetNodeSupply(i, supplies[i])\n # Find the minimum cost flow between node s' and t'.\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\n print('Minimum cost:', min_cost_flow.OptimalCost())\n print('')\n print(' Arc Flow / Capacity Cost')\n for i in range(min_cost_flow.NumArcs()):\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\n print('%1s -> %1s %3s / %3s %3s' % (\n min_cost_flow.Tail(i),\n min_cost_flow.Head(i),\n min_cost_flow.Flow(i),\n min_cost_flow.Capacity(i),\n cost))\n # update arcs\n start = min_cost_flow.Tail(i)\n destin = min_cost_flow.Head(i)\n if start != s_prime and \\\n start != t_prime and \\\n start != x and \\\n destin != s_prime and \\\n destin != t_prime and \\\n destin != x:\n # if forward, increase flow. otherwise decrease.\n print(\"Processing edge ({}, {})\".format(start, destin))\n if start < destin:\n sup_flow = min_cost_flow.Flow(i)\n else:\n sup_flow = -min_cost_flow.Flow(i)\n temp_start = start\n start = destin\n destin = temp_start\n print(\"Has become ({}, {}) with sup {}\".format(start,\n destin,\n sup_flow))\n arc = self.get_arc(start, destin)\n if (sup_flow != 0) or (\"lower_bound\" not in \\\n self.arc_info[arc].keys()):\n print(\"We should add this\")\n old_flow = self.arc_info[arc][\"weight\"]\n new_flow = old_flow + sup_flow\n self.arc_info[arc][\"weight\"] = int(new_flow)\n print(\"Edge ({},{}) weight is changed from {} to {}\".format(\n start,\n destin,\n old_flow,\n new_flow))\n else:\n print('There was an issue with the min cost flow input.')\n #self.check_conservation_of_flow() # check that solution is valid","def dfs_r(self, s):\n g = Graph(attr={DIRECTED: True})\n return self.dfs_rec(g, ('#', s))","def _ppsc_gossip(self):\n for i in range(self.s):\n for edges in self.all_edges:\n # for each connected component\n selected_edge = random.choice(edges)\n self._ppsc_gossip_edge(selected_edge)","def flows(self, flows):\n\n self._flows = flows","def get_reachable_nodes(self, source: Node) -> Set[Node]:\n nodes_found: Set[Node] = {source}\n queue = [source]\n while queue:\n v = queue.pop()\n for e in v.outgoing_edges:\n if e.node_to not in nodes_found:\n nodes_found.add(e.node_to)\n queue.append(e.node_to)\n return nodes_found","def gen_flows_from_choice(choice, flow_event_model, choice_stocks):\n rv = []\n i = 0\n try:\n while(True):\n up = choice[i+1]\n down = choice[i]\n up_stock_slug = up[0]\n down_stock_slug = down[0]\n up_slug = \"rising_%s\" % up_stock_slug\n up_name = \"Rising to %s\" % up[1].lower()\n down_slug = \"dropping_%s\" % down_stock_slug\n down_name = \"Dropping to %s\" % down[1].lower()\n rv.append(Flow(slug=up_slug, name=up_name, flow_event_model=flow_event_model,\n sources=[choice_stocks[down_stock_slug]],\n sinks=[choice_stocks[up_stock_slug]]))\n rv.append(Flow(slug=down_slug, name=down_name, flow_event_model=flow_event_model,\n sources=[choice_stocks[up_stock_slug]],\n sinks=[choice_stocks[down_stock_slug]]))\n i += 1\n except IndexError:\n pass\n return rv","def run(graph: Graph) -> List[Edge]:\n edges = sorted(WeightedEdge(edge) for edge in graph.get_edges())\n partitions = UnionFind()\n mst = []\n\n for edge in edges:\n added = partitions.union(edge.source, edge.target)\n if added:\n mst.append(edge._edge)\n\n if len(mst) == graph.get_number_of_nodes() - 1:\n break\n\n return mst","def max_flow(self, source, sink):\n\n max_flow = 0\n\n for i in range(self.V):\n for j in range(self.V):\n self.flow[i, j] = 0\n\n while self.bfs(source, sink):\n increment = maxint\n\n u = sink\n\n while self.pred[u] != -1:\n increment = min(\n increment, self.capacity[self.pred[u], u] - self.flow[self.pred[u], u])\n u = self.pred[u]\n\n u = sink\n\n while self.pred[u] != -1:\n self.flow[self.pred[u], u] += increment\n self.flow[u, self.pred[u]] -= increment\n u = self.pred[u]\n\n max_flow += increment\n\n return max_flow","def bfs(self, starting_vertex, destination_vertex):\n visited = set()\n paths = [[starting_vertex]]\n \"\"\"\n For every list in paths. If the last item in the list is \n the destination return the list. If the last item is not \n in the visited cache add it and make a new path for all \n of it's edges. If the last item has been visited remove \n it from the paths list.\n \"\"\"\n for path in paths:\n vertex = path[-1]\n if vertex == destination_vertex:\n return path\n if vertex not in visited:\n visited.add(vertex)\n for key in self.get_neighbors(vertex):\n newPath = path + [key]\n paths.append(newPath)","def get_all_social_paths(self, user_id): #each user v v each path V V\n # output example- {1: [1], 8: [1, 8], 10: [1, 10], 5: [1, 5], 2: [1, 10, 2], 6: [1, 10, 6], 7: [1, 10, 2, 7]}\n visited = {} # Note that this is a dictionary, not a set\n # Need to do a bfs using the user id\n # first step is to traverse the graph and record all the vertices as keys in visited using bft\n # then take those keys and use bfs on each, using user_id as the starting node and and the key as\n # the destination node\n\n # Modification of BFT\n # create an empty dict\n # q = Queue()\n q = []\n\n # init enqueue the starting node\n q.append(user_id)\n\n while len(q) > 0:\n # Dequeue the first item\n v = q.pop(0)\n # If it's not been visited:\n if v not in visited:\n # Mark as visited (i.e. add to the visited set)\n visited[v] = []\n\n # Do something with the node\n print(f\"Visited {v}\")\n\n # Add all neighbors to the queue\n for next_vert in self.friendships[v]:\n q.append(next_vert)\n\n # once visited is filled, then we start the bfs\n #print('vv',visited)\n possible_paths = {}\n #run a bfs for each key in visited\n for v in visited:\n possible_paths[v] = []\n \n if v == user_id:\n visited[v] = [user_id]\n\n path = []\n while len(path) < len(visited):\n\n # Add all neighbors to the queue\n for next_vert in self.friendships[v]:\n print(possible_paths[v])\n # copy the path\n # temp_path = list(path)\n # temp_path.append(next_vert)\n # add path to possible_paths\n path.append(next_vert)\n\n possible_paths[v].append(path) # HAVE TO USE QUEUE OR STACK, THEY ENSURE THE NEIGHBORS\n # FOLLOW THE CORRECT ORDER WHEN LOOPING \n\n if v == path[-1]:\n \n # IF SO, RETURN PATH\n visited[v] = path\n break\n\n # for x in visited:\n # bfs(user_id, x)\n # visited[x].add(path)\n \n print('pct of total users in network', len(visited[1])/len(visited))\n print('degrees of separation', len(visited[1]) - 1)\n return visited","def sens_flow_jsons(contexts: [{}], filter_flow) -> []:\n jsons = []\n for context in contexts:\n context_dir = context['dir']\n logger.debug(context_dir)\n for root, dirs, files in os.walk(context_dir):\n for file in files:\n if not file.endswith('_sens_http_flows.json'):\n continue\n with open(os.path.join(root, file), 'r', encoding=\"utf8\", errors='ignore') as infile:\n flows = json.load(infile)\n for flow in flows:\n if not filter_flow(flow):\n # The ground truth label, which is defined by \"context\" label.\n flow['real_label'] = context['label']\n jsons.append(flow)\n logger.info('The number of flows: %d', len(jsons))\n return jsons","def _get_staples(self, site, u, links=None):\n if links is None:\n links = self.links\n if len(links.shape) == 1:\n links = tf.reshape(links, self.links.shape)\n\n shape = self.site_idxs\n\n staples = []\n for v in range(self.dim): # u, v instead of mu, nu for readability\n if v != u:\n l1 = self.get_link(site + self.bases[u], v, shape, links)\n l2 = self.get_link(site + self.bases[v], u, shape, links)\n l3 = self.get_link(site, v, shape, links)\n\n l4 = self.get_link(site + self.bases[u] - self.bases[v],\n v, shape, links)\n l5 = self.get_link(site - self.bases[v], u, shape, links)\n l6 = self.get_link(site - self.bases[v], v, shape, links)\n\n if self.link_type == 'U1':\n _sum1 = l1 - l2 - l3\n _sum2 = -l4 -l5 + l6\n\n elif self.link_type in ['SU2', 'SU3']:\n prod1 = tf.matmul(l1, mat_adj(l2))\n prod1 = tf.matmul(prod1, mat_adj(l3))\n\n prod2 = tf.matmul(mat_adj(l3), mat_adj(l4))\n prod2 = tf.matmul(prod2, mat_adj(l6))\n\n _sum = prod1 + prod2\n\n #_arr = [_sum1, _sum2]\n staples.append(_sum1)\n staples.append(_sum2)\n\n return staples","def flow_graph_hash(graph):\n assert isinstance(graph, BasicGraph)\n sources = graph.nodes(in_degree=0)\n\n original_hash = 'original hash'\n new_hash = 'new_hash'\n cls = type(graph)\n hash_graph = cls() # new graph with hashes.\n visited = set()\n\n while sources:\n source = sources[0]\n sources = sources[1:]\n\n suppliers = graph.nodes(to_node=source)\n\n hash_func = hashlib.sha3_256()\n hash_func.update(bytes(str(source), 'utf-8'))\n for supplier in suppliers:\n if graph.depth_first_search(start=source, end=supplier):\n continue # it's a cycle.\n d = hash_graph.node(supplier)\n hash_func.update(bytes(d[new_hash], 'utf-8'))\n source_hash = hash_func.hexdigest()\n\n if source not in hash_graph:\n obj = {original_hash: source, new_hash: source_hash}\n hash_graph.add_node(source, obj=obj)\n else:\n n = hash_graph.node(source)\n n[new_hash] = source_hash\n\n receivers = graph.nodes(from_node=source)\n for receiver in receivers:\n if receiver in visited:\n continue\n visited.add(receiver)\n\n if receiver not in hash_graph:\n obj = {original_hash: receiver, new_hash: None}\n hash_graph.add_node(node_id=receiver, obj=obj)\n hash_graph.add_edge(source, receiver)\n if receiver not in sources:\n sources.append(receiver)\n\n for sink in graph.nodes(out_degree=0):\n n = hash_graph.node(sink)\n assert n[new_hash] is not None, n\n\n return hash_graph","def run_dfs(self,s):\n if self.verbose: print('entering run_dfs with s = ',s)\n new_states = [self.succ(s,a) for a in self.actions(s)]\n results = []\n\n for ns in new_states:\n if self.verbose: print('considering new state = ',ns)\n end = self.is_end(ns)\n if end:\n result = self.result(ns)\n if result is not None:\n results.append(result)\n else:\n results += self.run_dfs(ns)\n return results","def compute_flow(self, loads):\n assert len(loads) == self.n_nodes\n flow = np.zeros([self.n_nodes, self.n_nodes])\n for k, l in self.lines:\n flow[k, l] = self.line_flow(k, l, loads)\n return flow","def bfsSample(G, source=None, k = 50):\n\twarn(\"networkit.sampling.bfsSample is deprecated, will be removed in future updates.\")\n\tif not source:\n\t\tsource = GraphTools.randomNode(G)\n\tn = G.numberOfNodes()\n\tvisited = [False]*n\n\tQ = [source]\n\tclosest = set([source])\n\tglobal found\n\tfound = 0\n\twhile len(Q) > 0 and found < k:\n\t\tu = Q.pop(0)\n\t\tdef enqueue(u,v,weight, eid):\n\t\t\tglobal found\n\t\t\tif not visited[v] and found < k:\n\t\t\t\tfound += 1\n\t\t\t\tvisited[v] = True\n\t\t\t\tQ.append(v)\n\t\t\t\tclosest.add(v)\n\t\tG.forEdgesOf(u, enqueue)\n\tprint(\"found {0} nodes\".format(len(closest)))\n\tG1 = GraphTools.subgraphFromNodes(G, closest)\n\treturn G1","def shortest_flight(self):\r\n distance = sys.maxsize\r\n for code, _list in self.edges.items():\r\n for edge in _list:\r\n if edge.distance < distance:\r\n distance = edge.distance\r\n start = edge.start\r\n destination = edge.destination\r\n return start, destination, distance","def shortestPath(self, source, target):\n dist = {}\n prev = {}\n q = []\n for y,a in enumerate(self.sm):\n for x,b in enumerate(self.sm[y]):\n dist[(x,y)] = sys.maxint\n prev[(x,y)] = None\n q.append((x,y))\n dist[source] = 0\n\n while len(q) is not 0:\n # find the node with minimum value (u)\n d = deepcopy(dist)\n while True:\n b = dict(map(lambda item: (item[1],item[0]), d.items()))\n u = b[min(b.keys())]\n if u not in q:\n d.pop(u)\n else:\n break\n\n if dist[u] == sys.maxint: # remaining nodes are inaccessible\n break\n\n q.remove(u)\n\n\n if u == target: # target found\n break\n\n for v in self.getNeighbors(u):\n alt = dist[u] + 1\n if alt < dist[v]:\n dist[v] = alt\n prev[v] = u\n\n s = []\n u = target\n while prev[u] is not None:\n s.append(u)\n u = prev[u]\n s.reverse()\n\n return s","def bfs_nodes_generator(graph, source, reverse=...):\n ...","def gen_task_sets_fairgen(nsets):\n start = time()\n eval_task_sets = []\n for util in utils:\n task_sets = []\n for i in range(nsets):\n ts = synth.mc_fairgen(set_id=i, u_lo=util, implicit_deadlines=True)\n synth.synth_c_pmf(ts)\n synth.set_fixed_priorities(ts)\n task_sets.append(ts)\n eval_task_sets.append(task_sets)\n stop = time()\n print('Task Set Generation MC-Fairgen: %.3fs' % (stop - start))\n pickle.dump(eval_task_sets, open(task_sets_path + 'task_sets_fairgen', 'wb'))","def shiftFlows(self, targetFlows, stepSize):\n for l in self.link:\n current = self.link[l].flow\n target = targetFlows[l]\n new = current *(1 - stepSize)+target*stepSize\n self.link[l].flow = new\n self.link[l].updateCost()","def Run(self):\r\n # start all the flows along with updating related flow's transfer time\r\n while self.sched.toStartFlows:\r\n # the first flow is with earliest startTime\r\n curStartFlow = self.sched.toStartFlows[0]\r\n # update flows if there are flows has already finished\r\n while self.sched.runningFlows:\r\n # the first flow is with earliest finishTime\r\n toFinishFlow = self.sched.runningFlows[0]\r\n\r\n if toFinishFlow.finishTime <= curStartFlow.startTime:\r\n # remove this flow from running flows\r\n self.sched.runningFlows.remove(toFinishFlow)\r\n # add this flow to finished flows\r\n self.sched.finishedFlows.append(toFinishFlow)\r\n # Update related flow's transfer time in removing a flow\r\n self.sched.UpdateFlow(toFinishFlow, \"remove\")\r\n # Resort runningFlows by endTime\r\n self.sched.runningFlows.sort(key=lambda x: x.finishTime)\r\n else:\r\n break\r\n # insert current start flow to running list\r\n self.sched.runningFlows.append(curStartFlow)\r\n # Update related flow's transfer time in removing a flow\r\n self.sched.UpdateFlow(curStartFlow, \"insert\")\r\n # Resort runningFlows by endTime\r\n self.sched.runningFlows.sort(key=lambda x: x.finishTime)\r\n # remove this flow from start list\r\n self.sched.toStartFlows.remove(curStartFlow)\r\n\r\n # Now, all the flows are started\r\n # Iteratively update flow's transfer time in running list until all the flows are finished\r\n while self.sched.runningFlows:\r\n # the first flow is always with earliest finish Time\r\n curFinishFlow = self.sched.runningFlows[0]\r\n\r\n # remove it from running list\r\n self.sched.runningFlows.remove(curFinishFlow)\r\n # insert it to finished flows\r\n self.sched.finishedFlows.append(curFinishFlow)\r\n # Update related flow's transfer time in removing a flow\r\n self.sched.UpdateFlow(curFinishFlow, \"remove\")\r\n # Resort runningFlows by endTime\r\n self.sched.runningFlows.sort(key=lambda x: x.finishTime)\r\n\r\n # Finally, all the flows are finished\r\n self.sched.PrintFlows()","def flow_model():\n return {\n 'nodes': [\n {\n 'id': 'left_root',\n 'name': 'left_root',\n 'value': 3.5,\n 'rank': 'l',\n },\n {\n 'id': 'right_root',\n 'name': 'right_root',\n 'value': 3.5,\n 'rank': 'r',\n },\n ], 'edges': [\n {\n 'source': 'left_root',\n 'target': 'right_root',\n 'value': 1.0,\n },\n ]\n }","def dfs(self, starting_vertex, destination_vertex):\n # create an empty stack \n stack = Stack()\n #push the starting vertex ID as list\n stack.push([starting_vertex])\n # create an empty Set to store the visited vertices\n visited = set()\n # while the stack is not empty ...\n while stack.size() > 0:\n # pop the first vertex\n path = stack.pop()\n vert = path[-1]\n # if that vertex has not been visited ..\n if vert not in visited:\n #check for target\n if vert == destination_vertex:\n return path\n # mark it is visited\n visited.add(vert)\n # then add all of its neighbors to the top of the stack\n for neighbor in self.vertices[vert]: #self.get_neighbors(vert)\n #copy path to avoid pass by reference\n new_path = list(path) # make a copy\n new_path.append(neighbor)\n stack.push(new_path)","def get_segments(self, sets=None):\n if sets is None:\n if self.sets is not None:\n sets = self.sets\n else:\n raise ValueError(\"sets and self.sets attributes are None, \\\n you need either to pass an origin argument to get_segments or \\\n to use get_filtration method before\")\n segments = []\n for s in sets:\n if self.epsilon <= s.getRelevance():\n t, a, b = s.getPosition()\n for i, seg in enumerate(segments):\n tp, ap, bp = seg\n if t >= tp and bp > a:\n bp = a\n elif t <= tp and ap < b:\n ap = b\n segments[i] = (tp, ap, bp)\n segments.append((t, a, b))\n return segments","def sources(self):\n s = [node for node in self.nodes() if node.isSource()]\n s.sort(lambda x,y: cmp(x._id, y._id))\n return s","def get_flowgram_distances_on_cluster(\r\n id, flowgram, flowgrams, fc, ids, num_cores,\r\n num_flows, spread, client_sockets=[]):\r\n epoch = time()\r\n\r\n check_flowgram_ali_exe()\r\n\r\n qiime_config = load_qiime_config()\r\n min_per_core = int(qiime_config['denoiser_min_per_core'])\r\n # if using from future import division this has to be checked,\r\n # as we want true integer division here\r\n\r\n per_core = max(min_per_core, (num_flows / num_cores) + 1)\r\n names = []\r\n scores = []\r\n\r\n # Need to call this here, since we iterate over the same iterator repeatedly.\r\n # Otherwise the call in ifilter will reset the iterator by implicitely calling __iter__.\r\n # test if iter does the same\r\n flowgrams_iter = flowgrams.__iter__()\r\n # prepare input files and commands\r\n # synchronous client-server communication\r\n\r\n workload = compute_workload(num_cores, num_flows, spread)\r\n\r\n debug_count = 0\r\n for i in range(num_cores):\r\n socket = client_sockets[i]\r\n # send master flowgram to file first\r\n send_flowgram_to_socket(id, flowgram, socket)\r\n\r\n if(workload[i] < 1):\r\n # no data left for this poor guy\r\n save_send(socket, \"--END--\")\r\n continue\r\n else:\r\n # Then add all others which are still valid, i.e. in ids\r\n for (k, f) in (izip(range(workload[i]),\r\n ifilter(lambda f: f.Name in ids, flowgrams_iter))):\r\n fc.add(f)\r\n send_flowgram_to_socket(k, f, socket, trim=False)\r\n names.append(f.Name)\r\n debug_count += 1\r\n # send the termination signal\r\n save_send(socket, \"--END--\")\r\n\r\n # asynchronous client-server communication\r\n # ClientHandlers write data in results\r\n results = [None] * num_cores\r\n timing = [0.0 for x in xrange(num_cores)]\r\n for i in range(num_cores):\r\n socket = client_sockets[i]\r\n ClientHandler(socket, i, results, timing)\r\n loop()\r\n # end asynchronous loop\r\n\r\n spread = adjust_processing_time(num_cores, workload, timing, epoch)\r\n\r\n # flatten list\r\n scores = [item for list in results for item in list]\r\n\r\n if (debug_count != len(scores)):\r\n raise RuntimeError(\"Something bad has happened! I received less \" +\r\n \"alignment scores %d than there are flowgrams %d. Most likely this \"\r\n % (len(scores), debug_count) +\r\n \"means that the alignment program is not setup correctly or corrupted. \" +\r\n \"Please run the test scripts to figure out the cause of the error.\")\r\n\r\n return (scores, names, fc)","def bfs_edges_generator(graph, source, reverse=...):\n ...","def __dynamicThroughput( self, sourceSEs, destSEs ):\n res = self.__getTimeToStart()\n if not res['OK']:\n gLogger.error( res['Message'] )\n return {}\n channelInfo = res['Value']\n\n timeToSite = {} # Maintains time to site including previous hops\n siteAncestor = {} # Maintains the ancestor channel for a site\n tree = {} # Maintains replication tree\n while len( destSEs ) > 0:\n minTotalTimeToStart = float( \"inf\" )\n candidateChannels = []\n sourceActiveSEs = self.__getActiveSEs( sourceSEs )\n for destSE in destSEs:\n destSites = self.__getChannelSitesForSE( destSE )\n localTransfer = False\n for destSite in destSites:\n if localTransfer: break\n for sourceSE in sourceActiveSEs:\n if localTransfer: break\n sourceSites = self.__getChannelSitesForSE( sourceSE )\n for sourceSite in sourceSites:\n if localTransfer: break\n channelName = '%s-%s' % ( sourceSite, destSite )\n if channelInfo.has_key( channelName ):\n channelID = channelInfo[channelName]['ChannelID']\n if tree.has_key( channelID ):\n continue\n channelTimeToStart = channelInfo[channelName]['TimeToStart']\n if timeToSite.has_key( sourceSE ):\n totalTimeToStart = timeToSite[sourceSE] + channelTimeToStart + self.sigma\n else:\n totalTimeToStart = channelTimeToStart\n #print '%s-%s %s %s' % (sourceSE,destSE,channelTimeToStart,totalTimeToStart)\n localTransfer = ( sourceSite == destSite )\n if localTransfer or totalTimeToStart < minTotalTimeToStart:\n minTotalTimeToStart = totalTimeToStart\n selectedPathTimeToStart = totalTimeToStart\n candidateChannels = [( sourceSE, destSE, channelID )]\n elif totalTimeToStart == minTotalTimeToStart:\n candidateChannels.append( ( sourceSE, destSE, channelID ) )\n\n #minTotalTimeToStart = totalTimeToStart\n #selectedPathTimeToStart = totalTimeToStart\n #selectedSourceSE = sourceSE\n #selectedDestSE = destSE\n #selectedChannelID = channelID\n else:\n errStr = 'StrategyHandler.__dynamicThroughput: Channel not defined'\n gLogger.warn( errStr, channelName )\n\n #print 'Selected %s \\n' % selectedPathTimeToStart\n\n random.shuffle( candidateChannels )\n selectedSourceSE, selectedDestSE, selectedChannelID = candidateChannels[0]\n timeToSite[selectedDestSE] = selectedPathTimeToStart\n siteAncestor[selectedDestSE] = selectedChannelID\n\n if siteAncestor.has_key( selectedSourceSE ):\n waitingChannel = siteAncestor[selectedSourceSE]\n else:\n waitingChannel = False\n tree[selectedChannelID] = {}\n tree[selectedChannelID]['Ancestor'] = waitingChannel\n tree[selectedChannelID]['SourceSE'] = selectedSourceSE\n tree[selectedChannelID]['DestSE'] = selectedDestSE\n tree[selectedChannelID]['Strategy'] = 'DynamicThroughput'\n sourceSEs.append( selectedDestSE )\n destSEs.remove( selectedDestSE )\n return tree","def splitSources(sources: Iterable[FileId], chunkSize: int) -> List[List[FileId]]:\n if chunkSize <= 0:\n raise ValueError(f\"chunkSize must be positive ({chunkSize})\")\n\n sentinel = FileId(visit=math.nan, arm=None, spectrograph=None)\n sources = [sentinel] + sorted(sources, key=lambda x: x.visit) + [sentinel]\n\n # Split sources into sequences, each contiguous in terms of visits.\n contiguousSeqs = []\n for iscontiguous, group in itertools.groupby(\n zip(sources[:-1], sources[1:]),\n key=lambda pair: pair[1].visit - pair[0].visit == 1\n ):\n group = list(group)\n if iscontiguous:\n contiguousSeqs.append([pair[0] for pair in group] + [group[-1][-1]])\n else:\n contiguousSeqs.extend([pair[-1]] for pair in group[:-1])\n\n # Further split the contiguous sequences into small chunks\n chunks = []\n for seq in contiguousSeqs:\n n = len(seq)\n numChunks = (n + chunkSize - 1) // chunkSize\n quotient = n // numChunks\n remainder = n % numChunks\n for i in range(numChunks):\n if remainder > 0:\n remainder -= 1\n numToPop = quotient + 1\n else:\n numToPop = quotient\n chunks.append(seq[:numToPop])\n seq = seq[numToPop:]\n assert(len(seq) == 0)\n\n return chunks","def maximum_flow(graph, start, end):\n if not isinstance(graph, BasicGraph):\n raise TypeError(f\"Expected subclass of BasicGraph, not {type(graph)}\")\n Graph = type(graph)\n \n if start not in graph:\n raise ValueError(f\"{start} not in graph\")\n if end not in graph:\n raise ValueError(f\"{end} not in graph\")\n\n inflow = sum(d for s, e, d in graph.edges(from_node=start))\n outflow = sum(d for s, e, d in graph.edges(to_node=end))\n unassigned_flow = min(inflow, outflow) # search in excess of this 'flow' is a waste of time.\n total_flow = 0\n # -----------------------------------------------------------------------\n # The algorithm\n # I reviewed a number of algorithms, such as Ford-fulkerson algorithm,\n # Edmonson-Karp and Dinic, but I didn't like them due to their naive usage\n # of DFS, which leads to a lot of node visits.\n #\n # I therefore choose to invert the capacities of the graph so that the\n # capacity any G[u][v] = c becomes 1/c in G_inverted.\n # This allows me to use the shortest path method to find the path with\n # most capacity in the first attempt, resulting in a significant reduction\n # of unassigned flow.\n #\n # By updating G_inverted, with the residual capacity, I can keep using the\n # shortest path, until the capacity is zero, whereby I remove the links\n # When the shortest path method returns 'No path' or when unassigned flow\n # is zero, I exit the algorithm.\n #\n # Even on small graphs, this method is very efficient, despite the overhead\n # of using shortest path. For very large graphs, this method outperforms\n # all other algorithms by orders of magnitude.\n # -----------------------------------------------------------------------\n\n edges = [(n1, n2, 1 / d) for n1, n2, d in graph.edges() if d > 0]\n inverted_graph = Graph(from_list=edges) # create G_inverted.\n capacity_graph = Graph() # Create structure to record capacity left.\n flow_graph = Graph() # Create structure to record flows.\n\n while unassigned_flow:\n # 1. find the best path\n d, path = shortest_path(inverted_graph, start, end)\n if d == float(\"inf\"): # then there is no path, and we must exit.\n return total_flow, flow_graph\n # else: use the path and lookup the actual flow from the capacity graph.\n\n path_flow = min([min(d, capacity_graph.edge(s, e, default=float(\"inf\"))) for s, e, d in graph.edges(path=path)])\n\n # 2. update the unassigned flow.\n unassigned_flow -= path_flow\n total_flow += path_flow\n\n # 3. record the flows and update the inverted graph, so that it is\n # ready for the next iteration.\n edges = graph.edges(path)\n for n1, n2, d in edges:\n # 3.a. recording:\n v = flow_graph.edge(n1, n2, default=None)\n if v is None:\n flow_graph.add_edge(n1, n2, path_flow)\n c = graph.edge(n1, n2) - path_flow\n else:\n flow_graph.add_edge(n1, n2, value=v + path_flow)\n c = graph.edge(n1, n2) - (v + path_flow)\n capacity_graph.add_edge(n1, n2, c)\n\n # 3.b. updating:\n # if there is capacity left: update with new 1/capacity\n # else: remove node, as we can't do 1/zero.\n if c > 0:\n inverted_graph.add_edge(n1, n2, 1 / c)\n else:\n inverted_graph.del_edge(n1, n2)\n return total_flow, flow_graph","def dfs(self, starting_vertex, destination_vertex):\n \"\"\" LIFO\n Create a stack\n Create a set to store visited\n PUSH starting vertex into an array (STACK)\n While the STACK is NOT empty \n get((pop) first PATH vertex\n get Vertex from END of PATH\n check if NOT visited\n mark as visited\n check if vertex is destination_vertex\n If TRUE, return path \n PUSH path to ALL of neighbors\n make copy of current path\n add neighbor to path copy\n PUSH path copy\n \"\"\" \n s = Stack() # Create a stack\n s.push([starting_vertex]) # PUSH starting vertex into an array (STACK)\n visited = set() # Create a set to store visited\n\n while s.size() > 0: # While the STACK is NOT empty\n path = s.pop() # get(pop) first PATH vertex)\n v = path[-1] # get Vertex from END of PATH \n\n while v not in visited: # check if NOT visited\n visited.add(v) # mark as visited\n\n if v == destination_vertex: # check if vertex is destination_vertex\n return path # If TRUE, return path \n\n for n in self.get_neighbors(v): # PUSH path to ALL of neighbors\n path_c = path[:] # make copy of current path\n # path_c.extend([n]) # add neighbor to path copy\n path_c.append(n) # add neighbor to path copy\n s.push(path_c) # PUSH path copy","def build_solution_graph(self, graph, flows, connecting_graph=False):\n self.logger.info(\"Building solution graph\")\n self.clean_flow_cycles(flows)\n edges_to_keep = [e for e, flow in flows.items() if flow > 0]\n solution_graph_mdg = graph.edge_subgraph(edges_to_keep)\n\n if connecting_graph:\n # We add the edges to connect\n edges_to_keep = edges_to_keep + self.connecting_graph(solution_graph_mdg)\n # We rebuild the graph\n solution_graph_mdg = graph.edge_subgraph(edges_to_keep)\n\n # We add the flow attribute\n for e in edges_to_keep:\n solution_graph_mdg.edges[(e[0], e[1], 0)][config.SOLUTION_POWER_FLOW_KEY] = flows[e]\n\n # We convert it in GeoDiGraph\n solution_graph_mdg.crs = self.optimization_graph.crs\n solution_graph = gnx.GeoDiGraph(solution_graph_mdg, crs=solution_graph_mdg.crs)\n\n gnx.remove_isolates(solution_graph)\n solution_graph.name = \"solution_graph\"\n\n return solution_graph"],"string":"[\n \"def get_paths_for_flow(F, s, f):\\n links = [((u, v), split_ratio) \\n for (flow_id, u, v), split_ratio in F.items() \\n if flow_id == f and u == s and split_ratio > 0.001]\\n return links\",\n \"def get_paths_for_flow(F, s, f):\\n links = [((u, v), split_ratio) \\n for (flow_id, u, v), split_ratio in F.items() \\n if flow_id == f and u == s and split_ratio > 0.001]\\n return links\",\n \"def traverse_graph(F, f, s, t, u, sr):\\n def get_paths_for_flow(F, s, f):\\n \\\"\\\"\\\"\\n RETURNS\\n A set of outgoing links and corresponding splitting ratios for flow f\\n at node s\\n \\\"\\\"\\\"\\n links = [((u, v), split_ratio) \\n for (flow_id, u, v), split_ratio in F.items() \\n if flow_id == f and u == s and split_ratio > 0.001]\\n return links\\n \\n if u == t:\\n return [([t], sr)]\\n\\n outgoing_links = get_paths_for_flow(F, u, f)\\n paths_to_t = []\\n\\n for ((current_node, next_hop), split_ratio) in outgoing_links:\\n paths_from_u_to_t = traverse_graph(F, f, s, t, next_hop, split_ratio) \\n paths_to_t.extend(paths_from_u_to_t)\\n\\n paths_to_t_with_u = []\\n for path in paths_to_t:\\n nodes, sr = path\\n new_path = [u] + nodes\\n paths_to_t_with_u.append((new_path, sr))\\n\\n return paths_to_t_with_u\",\n \"def compute_equal_flow_allocations(target_graph, K=3):\\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\\n flow_allocation_seed_number = 0xDEAD_BEEF\\n np.random.seed(flow_allocation_seed_number)\\n flows = []\\n for node in target_graph.nodes:\\n possible_destination_nodes = set(target_graph.nodes) - set([node])\\n [destination_node] = np.random.choice(list(possible_destination_nodes), 1, replace=False)\\n # shortest_paths = all_shortest_paths(target_graph, node, destination_node.item())\\n shortest_paths = sorted(nx.all_simple_paths(target_graph, node, destination_node.item(),\\n cutoff=3),\\n key=lambda p: len(p))\\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\\n the_flow = Flow( source_node = node\\n , destination_node = destination_node.item()\\n , flow_tx_rate = 10.0\\n , paths = k_shortest_paths\\n , splitting_ratio = [1/K]*K\\n )\\n flows.append(the_flow)\\n \\n return flow_allocation_seed_number, flows\",\n \"def get_dfs(self, s):\\n results = []\\n # mark all the vertices as not visited\\n visited = [False] * (len(self.graph))\\n self._dfs_recursive(s, visited, results)\\n return results\",\n \"def max_flow(self, source, sink):\\n\\n path = self.valid_path(source, sink, [])\\n\\n while path:\\n # get the maximum possible flow that can be taken from this path:\\n max_flow = min([edge.capacity for edge in path])\\n for edge in path:\\n self.edges[edge] += max_flow\\n path = self.valid_path(source, sink, [])\\n\\n # Compute all the flows from the neighbors of source:\\n return sum([self.edges[edge] for edge in self.adjacents[source]])\",\n \"def compute_path_hopping_flow_allocations(target_graph, K=3):\\n flow_allocation_seed_number = 0xCAFE_BABE\\n np.random.seed(flow_allocation_seed_number)\\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\\n link_utilization = {(u, v): 0.0 for u, v in target_graph.edges}\\n node_capacity = {u: 0.0 for u in target_graph.nodes}\\n flows = []\\n while True:\\n source_node, destination_node = flow_selection_fn(target_graph.nodes, 2, replace=False)\\n print(source_node, destination_node)\\n\\n shortest_paths = sorted(nx.all_simple_paths(target_graph, source_node, destination_node,\\n cutoff=3),\\n key=lambda p: len(p))\\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\\n\\n # flow_tx_rate = np.random.uniform() * 10\\n flow_tx_rate = 1.0\\n # if node_capacity[source_node] + flow_tx_rate > LINK_CAPACITY:\\n # break\\n node_capacity[source_node] += flow_tx_rate\\n capacity_was_exceeded = False \\n for path in [nx.utils.pairwise(p_i) for p_i in k_shortest_paths]:\\n for u, v in [sorted(h_i) for h_i in path]:\\n flow_rate_per_subpath = flow_tx_rate / K\\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\\n capacity_was_exceeded = True\\n break\\n link_utilization[u, v] += flow_rate_per_subpath\\n if capacity_was_exceeded:\\n break\\n\\n if capacity_was_exceeded:\\n break\\n\\n the_flow = Flow( source_node = source_node\\n , destination_node = destination_node\\n , flow_tx_rate = flow_tx_rate\\n , paths = k_shortest_paths\\n , splitting_ratio = [1.0/K]*K\\n )\\n flows.append(the_flow)\\n return flows, link_utilization\",\n \"def ford_fulkerson_algorithm(graph: np.ndarray, source: int, sink: int) -> np.ndarray:\\r\\n\\r\\n residual_graph = copy.deepcopy(graph)\\r\\n row = len(residual_graph)\\r\\n parent = [-1] * row\\r\\n max_flow = 0\\r\\n\\r\\n if source == sink or sink < 0 or source < 0 or source >= row or sink >= row:\\r\\n raise WrongInputException('Wrong input source/sink vertice(s)')\\r\\n\\r\\n while bfs(residual_graph, row, source, sink, parent):\\r\\n\\r\\n path_flow = float(\\\"Inf\\\")\\r\\n s = sink\\r\\n while s != source:\\r\\n path_flow = min(path_flow, residual_graph[parent[s]][s])\\r\\n s = parent[s]\\r\\n\\r\\n max_flow += path_flow\\r\\n\\r\\n v = sink\\r\\n while v != source:\\r\\n u = parent[v]\\r\\n residual_graph[u][v] -= path_flow\\r\\n residual_graph[v][u] += path_flow\\r\\n v = parent[v]\\r\\n print(\\\"Max flow: %d\\\" % max_flow)\\r\\n\\r\\n return residual_graph\",\n \"def compute_greedy_flow_allocations( target_graph\\n , flow_selection_fn\\n , seed_number=DEFAULT_SEED_NUMBER):\\n\\n flow_allocation_seed_number = seed_number\\n np.random.seed(flow_allocation_seed_number)\\n\\n link_utilization = {tuple(sorted(link_tuple)): 0.0 for link_tuple in target_graph.edges}\\n flows = []\\n\\n while True:\\n capacity_was_exceeded = False\\n\\n source_node, destination_node = flow_selection_fn(target_graph.nodes)\\n flow_tx_rate = np.random.uniform(FLOW_TX_RATE_LOWER_BOUND, FLOW_TX_RATE_UPPER_BOUND)\\n\\n connecting_paths = list(node_disjoint_paths(target_graph, source_node, destination_node))\\n disjoint_path_count = len(connecting_paths)\\n flow_rate_per_subpath = flow_tx_rate / disjoint_path_count\\n for path in [nx.utils.pairwise(p_i) for p_i in connecting_paths]:\\n for u, v in [tuple(sorted(t_i)) for t_i in path]:\\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\\n capacity_was_exceeded = True\\n break\\n link_utilization[u, v] += flow_rate_per_subpath\\n if capacity_was_exceeded:\\n break\\n if capacity_was_exceeded:\\n break\\n\\n the_flow = Flow( source_node = source_node\\n , destination_node = destination_node\\n , flow_tx_rate = flow_tx_rate\\n , paths = connecting_paths\\n , splitting_ratio = [1.0/disjoint_path_count]*disjoint_path_count\\n )\\n flows.append(the_flow)\\n return flows, link_utilization\",\n \"def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\\n demand: float,\\n routing: np.ndarray) -> np.ndarray:\\n edge_mapping = {edge: i for i, edge in\\n enumerate(sorted(self.graph.edges))}\\n\\n link_utilisation = np.zeros(self.num_edges)\\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\\n node_flow[flow[0]] = demand\\n\\n to_explore = [flow[0]]\\n while to_explore:\\n current_node = to_explore.pop(0)\\n current_flow = node_flow[current_node]\\n\\n # this is the flow destination node so we absorb all flow\\n if current_node == flow[1]:\\n node_flow[current_node] = 0.0\\n continue\\n\\n # push the flow at this node over all edges\\n for edge in self.graph.out_edges(current_node):\\n edge_index = edge_mapping[edge]\\n ratio = routing[edge_index]\\n flow_to_send = ratio * current_flow\\n # only send flow if greater than epsilon (so no 'infinite' loops)\\n if flow_to_send > 1.e-8:\\n node_flow[edge[1]] += ratio * current_flow\\n # all important step, update our output\\n link_utilisation[edge_index] += ratio * current_flow\\n # have updated the dst so add it to the list of things to do\\n to_explore.append(edge[1])\\n # we've moved all the flow from this node now, so reset back to zero\\n node_flow[current_node] = 0.0\\n\\n return link_utilisation\",\n \"def DRBFS(self, flow, edge_mark):\\n\\t\\t# Distance flag for each node\\n\\t\\td = {v:float('inf') for v in self.topo.nodes}\\n\\t\\t# Parent node for each node\\n\\t\\tpa = {v:-1 for v in self.topo.nodes}\\n\\t\\t# Request info\\n\\t\\ts = flow[0]\\n\\t\\tt = flow[1]\\n\\n\\t\\t# BFS to find a min-hop path\\n\\t\\tqueue = [s]; hdr = 0; d[s] = 0\\n\\t\\twhile hdr < len(queue):\\n\\t\\t\\tu = queue[hdr]\\n\\t\\t\\thdr += 1\\n\\n\\t\\t\\tfor v in self.topo.topo.neighbors(u):\\n\\t\\t\\t\\tif edge_mark[(u, v)] or d[v] <= d[u] + 1:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tqueue.append(v)\\n\\t\\t\\t\\td[v] = d[u] + 1\\n\\t\\t\\t\\tpa[v] = u\\n\\t\\t\\t\\tif v == t:\\n\\t\\t\\t\\t\\t# This is because when BFS on edges, the first time reaching t meaning the smallest hop it can be reached\\n\\t\\t\\t\\t\\thdr = len(queue)\\n\\t\\t\\t\\t\\tbreak\\n\\n\\t\\tif d[t] == float('inf'):\\n\\t\\t\\treturn False\\n\\n\\t\\tp = [t]; v = t\\n\\t\\twhile v != s and v != -1:\\n\\t\\t\\tv = pa[v]\\n\\t\\t\\tp.append(v)\\n\\t\\tp.reverse()\\n\\n\\t\\treturn p\",\n \"def sorted_nodes(self):\\r\\n def is_source(node, connections):\\r\\n for connection in connections:\\r\\n if node == connection[1]:\\r\\n return False\\r\\n return True\\r\\n\\r\\n def source_connections(node, connections):\\r\\n conns = set()\\r\\n for connection in connections:\\r\\n if node == connection[0]:\\r\\n conns.add(connection)\\r\\n return conns\\r\\n\\r\\n nodes = set(self.nodes.values())\\r\\n connections = self.connections.copy()\\r\\n sorted_nodes = []\\r\\n\\r\\n # Find source nodes:\\r\\n source_nodes = set([n for n in nodes if is_source(n, connections)])\\r\\n\\r\\n # while S is non-empty do\\r\\n while source_nodes:\\r\\n # remove a node n from S\\r\\n node = source_nodes.pop()\\r\\n # insert n into L\\r\\n sorted_nodes.append(node)\\r\\n\\r\\n # for each node m with an edge e from n to m do\\r\\n s_connections = source_connections(node, connections)\\r\\n for connection in s_connections:\\r\\n # remove edge e from the graph\\r\\n m = connection[1]\\r\\n connections.remove(connection)\\r\\n # if m has no other incoming edges then\\r\\n # insert m into S\\r\\n if is_source(m, connections):\\r\\n source_nodes.add(m)\\r\\n\\r\\n # if graph has edges then\\r\\n # output error message (graph has at least one cycle)\\r\\n # else\\r\\n # output message (proposed topologically sorted order: L)\\r\\n\\r\\n if connections:\\r\\n raise Exception(\\\"Steram has at least one cycle (%d connections left of %d)\\\" % (len(connections), len(self.connections)))\\r\\n\\r\\n return sorted_nodes\",\n \"def flowers(self):\\n return self._flowers\",\n \"def test_sources():\\n g = Graph(from_list=[\\n (1, 3, 1),\\n (2, 4, 1),\\n (2, 5, 1),\\n (3, 5, 1),\\n (4, 6, 1),\\n (5, 6, 1),\\n ])\\n g.add_node(7)\\n s = g.sources(5)\\n e = {1, 2, 3}\\n assert s == e\\n\\n s2 = g.sources(1)\\n e2 = set()\\n assert s2 == e2, s2\\n\\n s3 = g.sources(6)\\n e3 = {1, 2, 3, 4, 5}\\n assert s3 == e3\\n\\n s4 = g.sources(7)\\n e4 = set()\\n assert s4 == e4\",\n \"def dijkstra(self, s, t):\\n l = []\\n dist = {}\\n prev = {}\\n discovered = {}\\n for v in self.get_vertices():\\n dist[v] = float('inf')\\n prev[v] = None\\n discovered[v] = False\\n dist[s] = 0\\n l.append((s, dist[s]))\\n while len(l) != 0:\\n u = min(l, key=lambda x: x[1])\\n l.remove(u)\\n u = u[0]\\n discovered[u] = True\\n if u == t:\\n break\\n for v in self.get_adjacent_vertices_by_vertex(u):\\n if not discovered[v]:\\n alt = dist[u] + self.get_edge((u, v)).attr[\\\"WEIGHT\\\"]\\n if alt < dist[v]:\\n dist[v] = alt\\n prev[v] = u\\n l.append((v, dist[v]))\\n # Create a graph according to visited nodes store in prev array\\n u = t\\n g = Graph(attr={DIRECTED: True})\\n while u is not None:\\n g.add_vertex(vertex.Vertex(u, {\\\"WEIGHT\\\": dist[u]}))\\n if prev[u] is not None:\\n g.add_vertex(vertex.Vertex(prev[u], {\\\"WEIGHT\\\": dist[prev[u]]}))\\n g.add_edge(edge.Edge(prev[u], u))\\n u = prev[u]\\n else:\\n break\\n return g\",\n \"def get_flow_6frames(self, flows_forward, flows_backward, flows_forward2, flows_backward2):\\n d = flows_forward2[0].shape[1]\\n flows_backward3 = []\\n for flows, flows2 in zip(flows_backward, flows_backward2):\\n flow_list = []\\n for i in range(d - 1, 0, -1):\\n flow_n1 = flows2[:, i - 1, :, :, :]\\n flow_n2 = flows[:, i + 1, :, :, :]\\n flow_list.insert(0, flow_n1 + flow_warp(flow_n2, flow_n1.permute(0, 2, 3, 1)))\\n flows_backward3.append(torch.stack(flow_list, 1))\\n flows_forward3 = []\\n for flows, flows2 in zip(flows_forward, flows_forward2):\\n flow_list = []\\n for i in range(2, d + 1):\\n flow_n1 = flows2[:, i - 1, :, :, :]\\n flow_n2 = flows[:, i - 2, :, :, :]\\n flow_list.append(flow_n1 + flow_warp(flow_n2, flow_n1.permute(0, 2, 3, 1)))\\n flows_forward3.append(torch.stack(flow_list, 1))\\n return flows_backward3, flows_forward3\",\n \"def dfs(self, s):\\n g = Graph(attr={DIRECTED: True})\\n adjacent_type = '+' if DIRECTED in self.attr and self.attr[\\n DIRECTED] else None\\n # Insert s root node in stack \\n stack = collections.deque()\\n # Initial node does not have origin, it is represented by # \\n stack.append(('#', s))\\n\\n while (len(stack) > 0):\\n (source, target) = stack.pop()\\n w = self.get_vertex(target)\\n if DISCOVERED not in w.attributes or w.attributes[\\n DISCOVERED] is False:\\n w.attributes[DISCOVERED] = True\\n g.add_vertex(w)\\n if (source != '#'):\\n g.add_edge(edge.Edge(source, w.id), True)\\n for e in self.get_adjacent_vertices_by_vertex(w.id,\\n adjacent_type):\\n stack.append((w.id, e))\\n return g\",\n \"def get_routing_solution(self):\\n G = self.base_digraph\\n s1 = self.sources[0]\\n s2 = self.sources[1]\\n t1 = self.destinations[0]\\n t2 = self.destinations[1]\\n\\n try:\\n m = Model('routing')\\n m.setParam('OutputFlag', False)\\n\\n # variables,\\n # We have one variable per edge per session\\n # e is the dict of dict for the variables\\n e = {}\\n r = {}\\n for i in [1,2]:\\n e[i] = {}\\n r[i] = m.addVar()\\n for u,v in G.edges():\\n e[i][u,v] = m.addVar(lb=0)\\n\\n m.update()\\n\\n obj = quicksum(r.values())\\n m.setObjective(obj, GRB.MAXIMIZE)\\n\\n # constraints\\n # 1. conservations of flow at all intermediate nodes\\n # 2. capacity constraints for each edge\\n\\n for u,v in G.edges():\\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\\n\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\\n\\n for n in G.nodes():\\n if n not in [s1, s2, t1, t2]:\\n for i in [1, 2]:\\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\\n m.addConstr(inflow == outflow)\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n for u, v in G.edges():\\n G[u][v]['Routing'] = {}\\n G[u][v]['Routing'][1] = e[1][u,v].x\\n G[u][v]['Routing'][2] = e[2][u,v].x\\n return (m.objVal, r[1].x, r[2].x)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong, no optimal solution obtained\\\"\\n return None, None, None\\n\\n except GurobiError:\\n Print ('Error Report from Gurobi')\",\n \"def set_random_session(self, G, degree_s):\\n sorted_nodes = nx.topological_sort(G)\\n num_nodes = G.number_of_nodes()\\n\\n # create sources and destinations of each of the sections\\n # name the nodes to be the last 4 numbers\\n srcs = [num_nodes, num_nodes + 1]\\n dsts = [num_nodes + 2, num_nodes + 3]\\n\\n end_idx = int(0.3 * len(sorted_nodes))\\n end_idx = max(end_idx, 2)\\n for i in range(2):\\n s = srcs[i]\\n t = dsts[i]\\n reachables = []\\n iter_num = 0\\n\\n while len(reachables) == 0:\\n iter_num += 1\\n if iter_num > 100:\\n end_idx = end_idx * 2\\n\\n # pick an entry point from the first 30%\\n entry_point = random.choice(sorted_nodes[:end_idx])\\n # print \\\"Source \\\", i\\n # print \\\"candidates: \\\", sorted_nodes[:end_idx]\\n # print \\\"entry point: \\\", entry_point\\n # print \\\"all nodes: \\\", G.nodes()\\n\\n # pick a random point from the reachables\\n reachables = nx.shortest_path(G, entry_point)\\n del reachables[entry_point]\\n #print \\\"reachables: \\\", reachables\\n reachables = reachables.keys()\\n\\n exit_point = random.choice(reachables)\\n #print \\\"exit_point: \\\", exit_point\\n\\n if degree_s[i]:\\n G.add_edge(s, entry_point, weight=degree_s[i])\\n G.add_edge(exit_point, t, weight=degree_s[i])\\n else:\\n # figure out the out_degree of entry point\\n out_degree = np.sum(G[u][v]['weight'] for u,v in G.out_edges(entry_point))\\n G.add_edge(s, entry_point, weight=out_degree)\\n\\n # figure out the int_degree of exit point\\n in_degree = np.sum(G[u][v]['weight'] for u,v in G.in_edges(exit_point))\\n G.add_edge(exit_point, t, weight=in_degree)\\n\\n edges = G.edges()\\n for u, v in edges:\\n par_num = int(G[u][v]['weight'])\\n for i in range(par_num):\\n self.add_edge(u, v)\\n\\n # set indices etc\\n self.set_sources(srcs)\\n self.set_destinations(dsts)\\n self.set_indices()\\n #print \\\"number of nodes: \\\" + str(self.number_of_nodes())\\n #print \\\"number of edges: \\\" + str(self.number_of_edges())\",\n \"def dfs_edges_generator(graph, source, reverse=...):\\n ...\",\n \"def find_flows(flows,\\n source_query,\\n target_query,\\n flow_query=None,\\n ignore_edges=None):\\n if flow_query is not None:\\n flows = flows[eval_selection(flows, '', flow_query)]\\n\\n if source_query is None and target_query is None:\\n raise ValueError('source_query and target_query cannot both be None')\\n\\n elif source_query is None and target_query is not None:\\n qt = eval_selection(flows, 'target', target_query)\\n qs = (~eval_selection(flows, 'source', target_query) &\\n ~flows.index.isin(ignore_edges or []))\\n\\n elif source_query is not None and target_query is None:\\n qs = eval_selection(flows, 'source', source_query)\\n qt = (~eval_selection(flows, 'target', source_query) &\\n ~flows.index.isin(ignore_edges or []))\\n\\n else:\\n qs = eval_selection(flows, 'source', source_query)\\n qt = eval_selection(flows, 'target', target_query)\\n\\n f = flows[qs & qt]\\n if source_query is None:\\n internal_source = None\\n else:\\n internal_source = flows[qs & eval_selection(flows, 'target',\\n source_query)]\\n if target_query is None:\\n internal_target = None\\n else:\\n internal_target = flows[qt & eval_selection(flows, 'source',\\n target_query)]\\n\\n return f, internal_source, internal_target\",\n \"def generate_simple_flows(tgen_names, num_bots, bot_msg_size, bot_msg_rate, num_comps, comp_msg_size, comp_msg_rate):\\n bot_tgen_ips = [TGEN_IP_PATTERN.format(TGEN_SUBNET_BASE + i) for i in range(num_bots)]\\n bot_tgen_ports = [TGEN_PORT_BASE + i for i in range(num_bots)]\\n\\n # competitor IPs and port numbers start after those assigned to the bots\\n comp_tgen_ips = [TGEN_IP_PATTERN.format(TGEN_SUBNET_BASE + i) for i in range(num_bots, num_bots+num_comps)]\\n comp_tgen_ports = [TGEN_PORT_BASE + i for i in range(num_bots, num_bots+num_comps)]\\n\\n # build up flows for bots. Each bot talks to every other bot.\\n bot_flows = {}\\n for i in range(num_bots):\\n bot_flows[i] = {\\\"flows\\\": [], \\\"tgen_name\\\": tgen_names[i]}\\n\\n # add a flow for each neighbor bot\\n for j in range(len(bot_tgen_ips)):\\n # don't add flows to self\\n if i != j:\\n # send from a unique source port based on the DESTINATION node.\\n # use a destination port based on the SOURCE node number\\n bot_flows[i][\\\"flows\\\"].append({\\\"src_port\\\": bot_tgen_ports[j],\\n \\\"dst_ip\\\": bot_tgen_ips[j],\\n \\\"dst_port\\\": bot_tgen_ports[i],\\n \\\"msg_rate\\\": bot_msg_rate,\\n \\\"msg_size\\\": bot_msg_size,\\n })\\n\\n # build up flows for competitor nodes. Each competitor node talks to every other competitor node.\\n comp_flows = {}\\n for i in range(num_comps):\\n comp_flows[i] = {\\\"flows\\\": [], \\\"tgen_name\\\": tgen_names[i+num_bots]}\\n\\n # add a flow for each neighbor bot\\n for j in range(len(comp_tgen_ips)):\\n # don't add flows to self\\n if i != j:\\n # send from a unique source port based on the DESTINATION node.\\n # use a destination port based on the SOURCE node number\\n comp_flows[i][\\\"flows\\\"].append({\\\"src_port\\\": comp_tgen_ports[j],\\n \\\"dst_ip\\\": comp_tgen_ips[j],\\n \\\"dst_port\\\": comp_tgen_ports[i],\\n \\\"msg_rate\\\": comp_msg_rate,\\n \\\"msg_size\\\": comp_msg_size,\\n })\\n\\n return bot_flows, comp_flows\",\n \"def _compute_flows(paths):\\n assert isinstance(paths, list)\\n\\n # allocate memory\\n flows = np.zeros([len(paths), FLAGS.target_height, FLAGS.target_width, 2],\\n dtype=np.float32)\\n\\n # load all images\\n pbar = ProgressBar(max_value=len(paths))\\n for i in range(len(paths)-1):\\n im1 = skimage.io.imread(paths[i])\\n im2 = skimage.io.imread(paths[i+1])\\n\\n im1 = cv2.cvtColor(im1, cv2.COLOR_RGB2GRAY)\\n im2 = cv2.cvtColor(im2, cv2.COLOR_RGB2GRAY)\\n im1 = skimage.transform.resize(\\n im1, [FLAGS.target_height, FLAGS.target_width], preserve_range=True,\\n mode='constant', anti_aliasing=True)\\n im2 = skimage.transform.resize(\\n im2, [FLAGS.target_height, FLAGS.target_width], preserve_range=True,\\n mode='constant', anti_aliasing=True)\\n flow = cv2.calcOpticalFlowFarneback(\\n im1, im2, flow=None, pyr_scale=0.5, levels=3, winsize=15,\\n iterations=3, poly_n=5, poly_sigma=1.2, flags=0)\\n\\n # store images\\n flows[i] = flow\\n pbar.update(i)\\n\\n # Replicate the flow for last frame\\n flows[-1] = flow\\n return flows\",\n \"def make_flow_graph(interaction_logs):\\n G = pgv.AGraph(directed=True)\\n\\n for module_id in interaction_logs['module_id'].unique():\\n G.add_node(module_id)\\n\\n E = defaultdict(set)\\n grouped = interaction_logs.groupby('user_id')\\n for user_id, group in grouped:\\n module_ids_in_student_path = group['module_id']\\n for source_node, target_node in zip(module_ids_in_student_path[:-1], module_ids_in_student_path[1:]):\\n if source_node != target_node: # stationary\\n E[(source_node, target_node)] |= {user_id}\\n\\n for (source_node, target_node), students_that_made_transition in E.iteritems():\\n G.add_edge(\\n source_node,\\n target_node,\\n weight=len(students_that_made_transition))\\n\\n return G\",\n \"def dijkstra(vs, es, s, stop = None):\\n initialize_single_source(vs, es, s)\\n key = lambda x: -1 * x._ss_d\\n Q = pq(vs)\\n edict = defaultdict(set)\\n for e in es:\\n edict[e.v1].add(e)\\n edict[e.v2].add(e)\\n\\n for i in range(len(vs)):\\n # min path to u is determined at end of loop\\n u = Q.pop()\\n for e in edict[u]:\\n v = e.v1 if e.v1 != u else e.v2\\n relax(u, v, e, Q)\\n if u == stop: return \\n \\n result = [v._ss_d for v in vs]\\n return result\",\n \"def _load_flows(paths):\\n assert isinstance(paths, list)\\n # allocate memory\\n flows = np.zeros([len(paths), FLAGS.target_height, FLAGS.target_width, 2],\\n dtype=np.float32)\\n\\n # load all flows\\n pbar = ProgressBar(max_value=len(paths)-1)\\n for i in range(len(paths)):\\n # Load flow\\n flow = np.load(paths[i])\\n\\n # Central crop flow\\n h, w, _ = flow.shape\\n left = (w - FLAGS.target_width) // 2\\n top = (h - FLAGS.target_height) // 2\\n right = left + FLAGS.target_width\\n bottom = top + FLAGS.target_height\\n flow = flow[left:right, top:bottom, :]\\n\\n # Store flow\\n flows[i] = flow\\n pbar.update(i)\\n return flows\",\n \"def hash_flow(flow_5_tuple):\\n ip_A = flow_5_tuple[0]\\n ip_B = flow_5_tuple[1]\\n tp_src = flow_5_tuple[2]\\n tp_dst = flow_5_tuple[3]\\n proto = flow_5_tuple[4]\\n if proto == 6:\\n #*** Is a TCP flow:\\n if ip_A > ip_B:\\n direction = 1\\n elif ip_B > ip_A:\\n direction = 2\\n elif tp_src > tp_dst:\\n direction = 1\\n elif tp_dst > tp_src:\\n direction = 2\\n else:\\n direction = 1\\n else:\\n #*** Isn't a flow, so arbitrarily set direction as 1:\\n direction = 1\\n if direction == 1:\\n flow_tuple = (ip_A, ip_B, tp_src, tp_dst, proto)\\n else:\\n #*** Flip direction:\\n flow_tuple = (ip_B, ip_A, tp_dst, tp_src, proto)\\n return hash_tuple(flow_tuple)\",\n \"def step(nodes, outputs, edges):\\n flowed = []\\n for node_name in nodes.copy():\\n if node_name in flowed:\\n continue\\n if len(nodes[node_name]) == 2:\\n if node_name in flowed:\\n continue\\n node = [int(value) for value in nodes[node_name]]\\n low_value, high_value = min(node), max(node)\\n low_flow, high_flow = edges[node_name] \\n low_dictionary, low_node_name = low_flow\\n high_dictionary, high_node_name = high_flow\\n low_node = low_dictionary.get(low_node_name, tuple())\\n high_node = high_dictionary.get(high_node_name, tuple())\\n low_dictionary[low_node_name] = low_node + (str(low_value),)\\n high_dictionary[high_node_name] = high_node + (str(high_value),)\\n nodes[node_name] = tuple()\\n if low_dictionary is nodes:\\n flowed.append(low_node_name)\\n if high_dictionary is nodes:\\n flowed.append(high_node_name)\\n return nodes, outputs, edges\",\n \"def possible(self):\\n return [tuple(path) for path in nx.all_shortest_paths(self._gpm.Graph, source=self.source, target=self.target)]\",\n \"def bfs(self, s, visit=None):\\n visited = set()\\n\\n # initialize the queue with the start vertex\\n queue = deque([s])\\n \\n # loop until the queue is empty\\n while queue:\\n\\n # get the next vertex\\n v = queue.popleft()\\n\\n # skip it if it's already visited\\n if v in visited: continue\\n\\n # mark it visited, then invoke the visit function\\n visited.add(v)\\n if visit: visit(v)\\n\\n # add its out vertices to the queue\\n queue.extend(self.out_vertices(v))\\n\\n # return the visited vertices\\n return visited\",\n \"def get_all_pairs(G):\\n # list all (start,dest) pairs between which the route must be computed\\n pairs_list = [(start, dest) for dest in G.nodes for start in G.nodes]\\n\\n # shuffle all elements in-place\\n random.shuffle(pairs_list)\\n\\n # generate a set from the list\\n pairs_set = set(pairs_list)\\n\\n return pairs_list, pairs_set\",\n \"def ListAllFlows(client_id: str) -> List[rdf_flow_objects.Flow]:\\n return data_store.REL_DB.ReadAllFlowObjects(client_id=client_id)\",\n \"def find_all_feedback_from_FVS(lt_links, ls_FVS=None):\\n if not ls_FVS:\\n set_nodes = set([])\\n for t_link in lt_links:\\n set_nodes.add(t_link[0])\\n set_nodes.add(t_link[1])\\n ls_FVS = FVS_analysis.FVS_finding(list(set_nodes), lt_links)[0]\\n #if FVS nodes are already gained, pass this step\\n \\n llt_feedbacks = []\\n dic_ts_FVSnodepair_llt_downstreams = {}#{(FVS node1, FVS node2):list of lt_downstream which starts at FVS node1 and ends at FVS node2}\\n for s_FVSnode in ls_FVS:\\n llt_downstreams = find_all_downstream_from_seed(lt_links, s_FVSnode, ls_FVS)\\n for lt_downstream in llt_downstreams:\\n ts_FVSpair = (s_FVSnode, lt_downstream[-1][-1])\\n dic_ts_FVSnodepair_llt_downstreams.setdefault(ts_FVSpair,[]).append(lt_downstream)\\n \\n lts_cyclesofFVS = get_all_cycles(ls_FVS)\\n for ts_cycleofFVS in lts_cyclesofFVS:\\n if len(ts_cycleofFVS) == 1:\\n llt_feedbacks.extend(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[0],ts_cycleofFVS[0])])\\n else:\\n b_stopflag = False\\n lllt_feedbackfragment = []\\n for i in range(len(ts_cycleofFVS)-1):\\n lllt_feedbackfragment.append(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[i], ts_cycleofFVS[i+1])])\\n if not dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[i], ts_cycleofFVS[i+1])]:\\n b_stopflag = True\\n break\\n lllt_feedbackfragment.append(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[-1],ts_cycleofFVS[0])])\\n if not dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[-1],ts_cycleofFVS[0])]:\\n b_stopflag = True\\n if b_stopflag:\\n continue#if there is no feedback passing by all FVS nodes of that cycle, pass to next cycle\\n \\n llt_feedbacks_specific_cycle = lllt_feedbackfragment.pop(0)\\n while lllt_feedbackfragment:\\n llt_fragments_next = lllt_feedbackfragment.pop(0)\\n llt_feedbacks_updated = []\\n for lt_fragment in llt_feedbacks_specific_cycle:\\n for lt_fragment_next in llt_fragments_next:\\n ls_route = [t_link[1] for t_link in lt_fragment[:-1]]\\n ls_route_next = [t_link[1] for t_link in lt_fragment_next[:-1]]\\n if not set(ls_route).intersection(set(ls_route_next)):\\n llt_feedbacks_updated.append(lt_fragment+lt_fragment_next)\\n llt_feedbacks_specific_cycle = llt_feedbacks_updated\\n llt_feedbacks.extend(llt_feedbacks_specific_cycle)\\n\\n return llt_feedbacks\",\n \"def run_destination_reduction(self):\\n s = self.sources\\n t = self.destinations\\n\\n # get the union set of source edges\\n s_edges = [self.out_edges(x) for x in s]\\n s_edges_idx = [set(self.get_edges_indices(src)) for src in s_edges]\\n S = set.union(*s_edges_idx)\\n\\n # now starting from the sources\\n T_curr = [set(self.in_edges(x)) for x in t]\\n T_curr_idx = [set(self.get_edges_indices(x)) for x in T_curr]\\n T_union = set.union(*[set(x) for x in T_curr])\\n T_union_idx = set.union(*T_curr_idx)\\n self.dst_evolution_rec = [T_curr_idx]\\n\\n while not T_union_idx.issubset(S):\\n # get the edges out of the max-ordered node\\n tail_nodes = set([x[0] for x in T_union])\\n tail_nodes = tail_nodes - set(s)\\n v = max(tail_nodes, key=lambda p: self.node[p]['index'])\\n\\n E = set([edge for edge in T_union if edge[0] == v])\\n E_curr = [x.intersection(E) for x in T_curr]\\n\\n T_next = []\\n Uv = self.in_edges(v)\\n for (Ex, Tx) in zip(E_curr, T_curr):\\n if Ex:\\n T_next.append((Tx - Ex).union(Uv))\\n else:\\n T_next.append(Tx)\\n\\n T_curr = T_next\\n T_curr_idx = [set(self.get_edges_indices(x)) for x in T_curr]\\n self.dst_evolution_rec.append(T_curr_idx)\\n\\n T_union = set.union(*[set(x) for x in T_curr])\\n T_union_idx = set.union(*T_curr_idx)\",\n \"def min_path(vs, es, source, target):\\n dijkstra(vs, es, source, stop = target)\\n test = target\\n result = []\\n while test != source:\\n e = test._ss_edge\\n result.append(e)\\n test = e.v1 if e.v1 != test else e.v2\\n assert test == source and test._ss_edge is None\\n return result[::-1]\",\n \"def get_bfs(self, s):\\n # create a queue for BFS\\n queue = []\\n # mark all the vertices as not visited\\n visited = [False] * (len(self.graph))\\n # mark the start node as visited and enqueue it\\n visited[s] = True\\n queue.append(s)\\n results = []\\n\\n while queue:\\n # dequeue a vertex from queue and append to results.\\n p = queue.pop(0)\\n results.append(p)\\n # get all adjacent vertices of the dequeued vertex s,\\n # and for any unvisited adjacent, mark it visited and enqueue it.\\n for v in self.graph[p]:\\n if visited[v] is False:\\n visited[v] = True\\n queue.append(v)\\n\\n return results\",\n \"def get_flows(self, num_flows_per_entry):\\n flows = []\\n for tenant in self._tenants:\\n for contract in tenant.get_children(only_class=Contract):\\n providing_epgs = contract.get_all_providing_epgs()\\n consuming_epgs = contract.get_all_consuming_epgs()\\n for providing_epg in providing_epgs:\\n vlan_ifs = providing_epg.get_all_attached(L2Interface)\\n if len(vlan_ifs):\\n providing_vlan = vlan_ifs[0].encap_id\\n phys_ifs = vlan_ifs[0].get_all_attached(Interface)\\n if len(phys_ifs):\\n providing_phys_if = phys_ifs[0].name\\n for consuming_epg in consuming_epgs:\\n vlan_ifs = consuming_epg.get_all_attached(L2Interface)\\n if len(vlan_ifs):\\n consuming_vlan = vlan_ifs[0].encap_id\\n phys_ifs = vlan_ifs[0].get_all_attached(Interface)\\n if len(phys_ifs):\\n consuming_phys_if = phys_ifs[0].name\\n if providing_vlan == consuming_vlan and providing_phys_if == consuming_phys_if:\\n # Skip this case since traffic would be switched outside fabric\\n continue\\n for filter_entry in contract.get_all_filter_entries():\\n for i in range(0, num_flows_per_entry):\\n flow = Flow()\\n flow.ethertype = filter_entry.etherT\\n if flow.ethertype == 'arp':\\n flow.arp_opcode = filter_entry.arpOpc\\n flow.populate_random_ip_addresses()\\n elif flow.ethertype == 'ip':\\n flow.populate_random_ip_addresses()\\n flow.proto = filter_entry.prot\\n if flow.proto == '6' or flow.proto == '17':\\n dFromPort = int(filter_entry.dFromPort)\\n dToPort = int(filter_entry.dToPort)\\n sFromPort = int(filter_entry.sFromPort)\\n sToPort = int(filter_entry.sToPort)\\n if dFromPort == 0:\\n dFromPort = 1\\n dToPort += 1\\n if sFromPort == 0:\\n sFromPort = 1\\n sToPort += 1\\n if dToPort > 65534:\\n dToPort = 65534\\n if sToPort > 65534:\\n sToPort = 65534\\n flow.dport = str(random_number(dFromPort,\\n dToPort))\\n flow.sport = str(random_number(sFromPort,\\n sToPort))\\n if flow.proto == '6':\\n flow.tcp_rules = filter_entry.tcpRules\\n flow.svlan = providing_vlan\\n flow.dvlan = consuming_vlan\\n flow.src_intf = providing_phys_if\\n flow.dst_intf = consuming_phys_if\\n\\n # Is the flow expected to succeed ?\\n flow.expected_action = 'drop'\\n providing_bd = providing_epg.get_bd()\\n consuming_bd = consuming_epg.get_bd()\\n if providing_bd and consuming_bd:\\n if providing_bd == consuming_bd:\\n if providing_bd.get_context() == consuming_bd.get_context():\\n flow.expected_action = 'permit'\\n flow.populate_random_mac_addresses()\\n flows.append(flow)\\n return flows\",\n \"def _ism_get_mirror_sources(source, receiver, walls, order_threshold, mirrors_threshold):\\n logger.info(\\\"_ism_get_mirror_sources: Determining mirror sources.\\\")\\n model = ism.Model(walls=walls, source=source, receiver=receiver, max_order=order_threshold)\\n mirrors = model.determine(strongest=mirrors_threshold)\\n yield from mirrors\",\n \"def generate_graph(size, number_of_clusters, minimal_size):\\n base_list = list(range(size))\\n result_list = []\\n random.shuffle(base_list)\\n for i in range(number_of_clusters - 1):\\n size = random.randint(minimal_size, len(base_list) - (number_of_clusters - i - 1) * minimal_size)\\n cluster = []\\n for n in range(size):\\n actual = random.choice(base_list)\\n base_list.remove(actual)\\n cluster.append(actual)\\n result_list.append(strongly_connect(cluster))\\n result_list.append(strongly_connect(base_list))\\n\\n while len(result_list) < 5:\\n result_list.append([])\\n\\n print(sorted([len(i) for i in result_list], reverse=True)[:5])\\n\\n return weak_connect_graph(result_list)\",\n \"def generateNumsets(G):\\n # paths = []\\n #\\n # path = [0]\\n # for edge in nx.dfs_edges(G, 0):\\n # if edge[0] == path[-1]:\\n # path.append(edge[1])\\n # else:\\n # paths.append(path)\\n # search_index = 2\\n # while search_index <= len(path):\\n # if edge[0] == path[-search_index]:\\n # path = path[:-search_index + 1] + [edge[1]]\\n # break\\n # search_index += 1\\n # else:\\n # raise Exception(\\\"Wrong path structure?\\\", path, edge)\\n # paths.append(path)\\n # return paths\\n\\n \\\"\\\"\\\"\\n Trying to use itertools LMAO\\n \\\"\\\"\\\"\\n # paths = []\\n #\\n # for path in itertools.combinations(G.nodes, 5):\\n # paths.append(path)\\n # return paths\\n\\n \\\"\\\"\\\"\\n Generating paths using graph\\n \\\"\\\"\\\"\\n paths = []\\n n = len(G.nodes)\\n for source in range(n):\\n for target in range(source+1, n):\\n paths.extend([path for path in nx.all_simple_paths(G, source=source, target=target)])\\n return paths\\n\\n # return paths\",\n \"def objective(graph, flows):\\n\\n G = graph.copy()\\n rules = {}\\n flows.sort(key=lambda a: a[1], reverse=True)\\n\\n for flow,demand in flows:\\n src = get_host_from_ip(G, flow.nw_src)\\n dst = get_host_from_ip(G, flow.nw_dst)\\n\\n if not (src and dst):\\n continue\\n if not (src in G.nodes() and dst in G.nodes()):\\n continue\\n\\n path = widest_path(G, src, dst)\\n\\n hops = []\\n for a,b in pairwise(path):\\n hops.append(Hop(dpid=int(a[1:]), port=G.edge[a][b]['port']))\\n G.edge[a][b]['capacity'] -= demand\\n G.edge[b][a]['capacity'] -= demand\\n\\n rules[flow] = hops\\n\\n return rules\",\n \"def __generate_all_shortest_paths(self,cutoff = 10):\\n if cutoff < 1:\\n cutoff = 10\\n self.__logger.info(\\\"cutoff value must be a positive integer. Set back to default value: 10\\\")\\n\\n all_pair_shortest_paths = nx.all_pairs_shortest_path(self.G, cutoff=cutoff)\\n for item in all_pair_shortest_paths:\\n from_node = item[0]\\n paths = item[1]\\n for destination,path in paths.items():\\n yield (len(path),path)\",\n \"def compute_flow(self, lqs):\\n n, t, c, h, w = lqs.size()\\n lqs_1 = lqs[:, :-1, :, :, :].reshape(-1, c, h, w)\\n lqs_2 = lqs[:, 1:, :, :, :].reshape(-1, c, h, w)\\n flows_backward = self.spynet(lqs_1, lqs_2).view(n, t - 1, 2, h, w)\\n if self.is_mirror_extended:\\n flows_forward = None\\n else:\\n flows_forward = self.spynet(lqs_2, lqs_1).view(n, t - 1, 2, h, w)\\n return flows_forward, flows_backward\",\n \"def bfs (graph, src, tgt):\\n\\n if not graph.has_key(src):\\n raise AttributeError(\\\"The source '%s' is not in the graph\\\" % src)\\n if not graph.has_key(tgt):\\n raise AttributeError(\\\"The target '%s' is not in the graph\\\" % tgt)\\n\\n parents = {src: None}\\n queue = deque([src])\\n while queue:\\n node = queue.popleft()\\n for neighbor in graph[node]:\\n if neighbor not in parents:\\n parents[neighbor] = node\\n queue.append(neighbor)\\n if node == tgt:\\n break\\n\\n path = [tgt]\\n while parents[tgt] is not None:\\n path.insert(0, parents[tgt])\\n tgt = parents[tgt]\\n\\n return path\",\n \"def bfs(self, s):\\n g = Graph(attr={DIRECTED: True})\\n root = self.get_vertex(s)\\n root.attributes[DISCOVERED] = True\\n q = collections.deque()\\n adjacent_type = '+' if DIRECTED in self.attr and self.attr[\\n DIRECTED] else None\\n # Insert root node in graph and queue\\n g.add_vertex(root)\\n q.append(s)\\n\\n while (len(q) > 0):\\n v = q.popleft()\\n for e in self.get_adjacent_vertices_by_vertex(v, adjacent_type):\\n w = self.get_vertex(e)\\n if DISCOVERED not in w.attributes or w.attributes[\\n DISCOVERED] is False:\\n w.attributes[DISCOVERED] = True\\n q.append(w.id)\\n g.add_vertex(w)\\n g.add_edge(edge.Edge(v, e), True)\\n return g\",\n \"def _dfs(\\n self, kg: KG, entity: Vertex, is_reverse: bool = False\\n ) -> List[Walk]:\\n self.sampler.visited = set()\\n walks: List[Walk] = []\\n assert self.max_walks is not None\\n\\n rng = np.random.RandomState(self.random_state)\\n\\n while len(walks) < self.max_walks:\\n sub_walk: Walk = (entity,)\\n d = 1\\n while d // 2 < self.max_depth:\\n pred_obj = self.sampler.sample_hop(\\n kg, sub_walk, d // 2 == self.max_depth - 1, is_reverse\\n )\\n if pred_obj is None:\\n break\\n\\n if is_reverse:\\n if (\\n pred_obj[0] in self.communities\\n and rng.random() < self.hop_prob\\n ):\\n community_nodes = self.labels_per_community[\\n self.communities[pred_obj[0]]\\n ]\\n sub_walk = (\\n pred_obj[1],\\n rng.choice(community_nodes),\\n ) + sub_walk\\n else:\\n sub_walk = (pred_obj[1], pred_obj[0]) + sub_walk\\n else:\\n if (\\n pred_obj[1] in self.communities\\n and rng.random() < self.hop_prob\\n ):\\n community_nodes = self.labels_per_community[\\n self.communities[pred_obj[1]]\\n ]\\n sub_walk += (\\n pred_obj[0],\\n rng.choice(community_nodes),\\n )\\n else:\\n sub_walk += (pred_obj[0], pred_obj[1])\\n d = len(sub_walk) - 1\\n walks.append(sub_walk)\\n return list(walks)\",\n \"def sinks(self):\\n s = [node for node in self.nodes() if node.isSink()]\\n s.sort(lambda x,y: cmp(x._id, y._id))\\n return s\",\n \"def get_all_sghop_info (nffg, return_paths=False):\\n sg_map = {}\\n for i in nffg.infras:\\n for p in i.ports:\\n for fr in p.flowrules:\\n # if fr.external:\\n # continue\\n if fr.id not in sg_map:\\n # The path is unordered!!\\n path_of_shop = []\\n flowclass = NFFGToolBox._extract_flowclass(fr.match.split(\\\";\\\"))\\n sg_map[fr.id] = [None, None, flowclass, fr.bandwidth, fr.delay]\\n # We have to find the BEGINNING of this flowrule sequence.\\n inbound_link = NFFGToolBox._find_infra_link(nffg, p, outbound=False,\\n accept_dyn=True)\\n while inbound_link.type != 'DYNAMIC':\\n path_of_shop.append(inbound_link)\\n if inbound_link.src.node.type == 'SAP':\\n break\\n # The link is STATIC, and its src is not SAP so it is an Infra.\\n prev_fr, prev_p = \\\\\\n NFFGToolBox._get_flowrule_and_its_starting_port(\\n inbound_link.src.node, fr.id)\\n NFFGToolBox._check_flow_consistencity(sg_map, prev_fr)\\n inbound_link = NFFGToolBox._find_infra_link(nffg, prev_p,\\n outbound=False,\\n accept_dyn=True)\\n # 'inbound_link' is DYNAMIC here or it is STATIC and starts from\\n # a SAP,\\n # so the sequence starts here\\n sg_map[fr.id][0] = inbound_link.src\\n\\n # We have to find the ENDING of this flowrule sequence.\\n output_port = NFFGToolBox._get_output_port_of_flowrule(i, fr)\\n if output_port is None:\\n continue\\n outbound_link = NFFGToolBox._find_infra_link(nffg, output_port,\\n outbound=True,\\n accept_dyn=True)\\n while outbound_link.type != 'DYNAMIC':\\n path_of_shop.append(outbound_link)\\n if outbound_link.dst.node.type == 'SAP':\\n break\\n # The link is STATIC and its dst is not a SAP so it is an Infra.\\n next_fr, _ = NFFGToolBox._get_flowrule_and_its_starting_port(\\n outbound_link.dst.node, fr.id)\\n # '_' is 'outbound_link.dst'\\n next_output_port = NFFGToolBox._get_output_port_of_flowrule(\\n outbound_link.dst.node, next_fr)\\n NFFGToolBox._check_flow_consistencity(sg_map, next_fr)\\n outbound_link = NFFGToolBox._find_infra_link(nffg,\\n next_output_port,\\n outbound=True,\\n accept_dyn=True)\\n # the 'outbound_link' is DYNAMIC here or finishes in a SAP, so the\\n # flowrule sequence finished here.\\n sg_map[fr.id][1] = outbound_link.dst\\n\\n if return_paths:\\n sg_map[fr.id].append(path_of_shop)\\n\\n return sg_map\",\n \"def ECMPBFS(self, flow, edge_mark):\\n\\t\\t# Distance flag for each node\\n\\t\\td = {v:float('inf') for v in self.topo.nodes}\\n\\t\\t# Parent node for each node\\n\\t\\tpa = {v:[] for v in self.topo.nodes}\\n\\t\\t# Request info\\n\\t\\ts = flow[0]\\n\\t\\tt = flow[1]\\n\\n\\t\\t# BFS to find a min-hop path\\n\\t\\tqueue = [s]; hdr = 0; d[s] = 0\\n\\t\\twhile hdr < len(queue):\\n\\t\\t\\tu = queue[hdr]\\n\\t\\t\\thdr += 1\\n\\n\\t\\t\\tfor v in self.topo.topo.neighbors(u):\\t# This is directed neighbors in the context\\n\\t\\t\\t\\tif edge_mark[(u, v)] or d[v] < d[u] + 1:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tif d[v] > d[u] + 1:\\n\\t\\t\\t\\t\\tqueue.append(v)\\n\\t\\t\\t\\t\\tpa[v] = [u]\\n\\t\\t\\t\\telif d[v] == d[u] + 1:\\n\\t\\t\\t\\t\\tpa[v].append(u)\\n\\t\\t\\t\\td[v] = d[u] + 1\\n\\n\\t\\tif d[t] == float('inf'):\\n\\t\\t\\treturn False\\n\\n\\t\\t# Iteratively find all paths until there is no\\n\\t\\tp_lst = []\\n\\t\\twhile True:\\n\\t\\t\\tp = [t]; v = t; branch = None; branch_idx = None\\n\\t\\t\\twhile v != s and v != -1:\\n\\t\\t\\t\\tif len(pa[v]) > 0:\\n\\t\\t\\t\\t\\tif pa[v] > 1:\\n\\t\\t\\t\\t\\t\\tbranch = v\\n\\t\\t\\t\\t\\t\\tbranch_idx = 0\\n\\t\\t\\t\\t\\tv = pa[v][0]\\n\\t\\t\\t\\t\\tp.append(v)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\tif v == s:\\n\\t\\t\\t\\tp.reverse()\\n\\t\\t\\t\\tp_lst.append(p)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\tif branch:\\n\\t\\t\\t\\tpa[branch].pop(branch_idx)\\n\\n\\t\\treturn p_lst\",\n \"def get_flow_4frames(self, flows_forward, flows_backward):\\n d = flows_forward[0].shape[1]\\n flows_backward2 = []\\n for flows in flows_backward:\\n flow_list = []\\n for i in range(d - 1, 0, -1):\\n flow_n1 = flows[:, i - 1, :, :, :]\\n flow_n2 = flows[:, i, :, :, :]\\n flow_list.insert(0, flow_n1 + flow_warp(flow_n2, flow_n1.permute(0, 2, 3, 1)))\\n flows_backward2.append(torch.stack(flow_list, 1))\\n flows_forward2 = []\\n for flows in flows_forward:\\n flow_list = []\\n for i in range(1, d):\\n flow_n1 = flows[:, i, :, :, :]\\n flow_n2 = flows[:, i - 1, :, :, :]\\n flow_list.append(flow_n1 + flow_warp(flow_n2, flow_n1.permute(0, 2, 3, 1)))\\n flows_forward2.append(torch.stack(flow_list, 1))\\n return flows_backward2, flows_forward2\",\n \"def gen_flow_session(self, set_choice, seq_len):\\r\\n return_seq = []\\r\\n chosen_set = self.split_flow[set_choice]\\r\\n\\r\\n for poi_index, group in chosen_set.groupby('poi_index'):\\r\\n for i in range(group.shape[0] - seq_len + 1):\\r\\n flow_seq = group['flow'].iloc[i:i+seq_len]\\r\\n if flow_seq.sum() > 0:\\r\\n return_seq.append([poi_index, flow_seq.to_list()])\\r\\n return return_seq\",\n \"def showFlow(self):\\r\\n def edgesFromVertex(u):\\r\\n \\\"\\\"\\\"\\r\\n Represents the flow across the given vertex.\\r\\n \\\"\\\"\\\"\\r\\n edgeRepresentation = lambda v: f\\\"({u}, {v}, {self.getCapacity((u, v))}, {self.getFlow((u,v))})\\\"\\r\\n return \\\", \\\".join(map(edgeRepresentation, sorted(self.adjacent[u])))\\r\\n\\r\\n def adjacencyLists():\\r\\n \\\"\\\"\\\"\\r\\n Represents the flow across all relevant vertices.\\r\\n \\\"\\\"\\\"\\r\\n anyNeighbor = lambda u: any(self.neighbors(u))\\r\\n verticesWithNeighbors = filter(anyNeighbor, sorted(self.vertices()))\\r\\n return map(edgesFromVertex, verticesWithNeighbors)\\r\\n\\r\\n return print(\\\"\\\\n\\\".join(adjacencyLists()))\",\n \"def calc_lp(self, demands: Demand, routing: Routing) -> float:\\n epsilon = self.epsilon\\n\\n # Create the linear solver with the GLOP backend.\\n solver = pywraplp.Solver('flow_utilisation_lp',\\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\\n\\n ## VARIABLES\\n # Flow variables, the amount of flow along each edge\\n # stored as a list flow_variables[ith_flow][jth_edge]\\n flow_variables = []\\n for i in range(len(self.commodities)):\\n flow_variable_edges = []\\n for j in range(len(self.edges)):\\n flow_variable_edges.append(\\n solver.NumVar(0, solver.infinity(), '({},{})'.format(i, j)))\\n flow_variables.append(flow_variable_edges)\\n\\n ## CONSTRAINTS\\n # Flow from source constraint (net flow must equal demand)\\n conservation_source_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # create constraint\\n constraint_i = solver.Constraint(demands[i] - epsilon,\\n demands[i] + epsilon,\\n '(source,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[0])]:\\n # out flow is positive\\n constraint_i.SetCoefficient(flow_variables[i][edge_index], 1)\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[0])]:\\n # in flow is negative\\n constraint_i.SetCoefficient(flow_variables[i][edge_index], -1)\\n conservation_source_constraints.append(constraint_i)\\n\\n # Flow to sink constraint (in flow must equal demand, out must be zero)\\n conservation_sink_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # create in flow constraint\\n constraint_i_in = solver.Constraint(-demands[i] - epsilon,\\n -demands[i] + epsilon,\\n '(sink_in,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[1])]:\\n # in flow is negative\\n constraint_i_in.SetCoefficient(flow_variables[i][edge_index],\\n -1)\\n conservation_sink_constraints.append(constraint_i_in)\\n\\n constraint_i_out = solver.Constraint(0, 0,\\n '(sink_out,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[1])]:\\n # out flow is positive\\n constraint_i_out.SetCoefficient(flow_variables[i][edge_index],\\n 1)\\n conservation_sink_constraints.append(constraint_i_out)\\n\\n # Flow at transit node constraint (net flow must be zero)\\n conservation_transit_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.graph.number_of_nodes()):\\n if j != commodity[0] and j != commodity[1]:\\n # create constraint\\n constraint_j = solver.Constraint(-epsilon, +epsilon,\\n '(transit,{},{})'.format(i,\\n j))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(j)]:\\n # out flow is positive\\n constraint_j.SetCoefficient(\\n flow_variables[i][edge_index],\\n 1)\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(j)]:\\n # in flow is negative\\n constraint_j.SetCoefficient(\\n flow_variables[i][edge_index],\\n -1)\\n constraints_flow_i.append(constraint_j)\\n conservation_transit_constraints.append(constraints_flow_i)\\n\\n # Flow splitting at transit constraints (edge flow must be correct split of\\n # in flow)\\n splitting_ratio_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.graph.number_of_nodes()):\\n # Sink has not such constraint and we handle source differently\\n if j != commodity[1] and j != commodity[0]:\\n in_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(j)]\\n out_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(j)]\\n\\n # separate constraint for split of each out_edge taking into\\n # account all in_edges\\n for out_edge_index in out_edges:\\n # create constraint\\n constraint_edge = \\\\\\n solver.Constraint(-epsilon, +epsilon,\\n '(split,{},{},{})'.format(\\n i, j,\\n out_edge_index))\\n split_ratio = routing[i][out_edge_index]\\n # flow on out edge\\n constraint_edge.SetCoefficient(\\n flow_variables[i][out_edge_index], 1)\\n for in_edge_index in in_edges:\\n # should equal sum of flow on all in edges scaled by\\n # split ratio\\n constraint_edge.SetCoefficient(\\n flow_variables[i][in_edge_index],\\n -1 * split_ratio)\\n constraints_flow_i.append(constraint_edge)\\n splitting_ratio_constraints.append(constraints_flow_i)\\n\\n # Flow splitting at source constraints (edge flow must be correct split of\\n # in flow + demand)\\n source_splitting_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n in_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[0])]\\n out_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[0])]\\n for out_edge_index in out_edges:\\n # create constraint\\n split_ratio = routing[i][out_edge_index]\\n split_demand = split_ratio * demands[i]\\n constraint_edge = \\\\\\n solver.Constraint(split_demand - epsilon,\\n split_demand + epsilon,\\n '(split,{},{},{})'.format(i, j,\\n out_edge_index))\\n # flow on out edge\\n constraint_edge.SetCoefficient(\\n flow_variables[i][out_edge_index], 1)\\n for in_edge_index in in_edges:\\n # should equal sum of flow on all in edges scaled by split ratio\\n constraint_edge.SetCoefficient(\\n flow_variables[i][in_edge_index],\\n -1 * split_ratio)\\n constraints_flow_i.append(constraint_edge)\\n source_splitting_constraints.append(constraints_flow_i)\\n\\n solver.Solve()\\n\\n result_status = solver.Solve()\\n\\n utilisation = np.zeros(\\n (len(self.commodities), self.graph.number_of_edges()))\\n # # extract the actual routing. Useful for debugging, maybe use to bootstrap\\n # assignment = np.zeros(\\n # (len(self.commodities), self.graph.number_of_edges()))\\n\\n # if routing is really that bad, just bail and give a sad result\\n if result_status == solver.NOT_SOLVED or result_status == solver.INFEASIBLE:\\n return 1.0\\n\\n for i in range(len(self.commodities)):\\n for j in range(self.graph.number_of_edges()):\\n utilisation[i][j] = flow_variables[i][j].solution_value() / \\\\\\n self.edges[j][2]['weight']\\n # assignment[i][j] = flow_variables[i][j].solution_value()\\n\\n return np.max(np.sum(utilisation, axis=0))\",\n \"def dijkstra_tree(self, s):\\n l = []\\n dist = {}\\n prev = {}\\n discovered = {}\\n g = Graph(attr={DIRECTED: True})\\n g.add_vertex(vertex.Vertex(s, {\\\"WEIGHT\\\": 0}))\\n for v in self.get_vertices():\\n dist[v] = float('inf')\\n prev[v] = None\\n discovered[v] = False\\n dist[s] = 0\\n l.append((s, dist[s]))\\n while len(l) != 0:\\n u = min(l, key=lambda x: x[1])\\n l.remove(u)\\n u = u[0]\\n discovered[u] = True\\n for v in self.get_adjacent_vertices_by_vertex(u):\\n if not discovered[v]:\\n alt = dist[u] + self.get_edge((u, v)).attr[\\\"WEIGHT\\\"]\\n if alt < dist[v]:\\n dist[v] = alt\\n prev[v] = u\\n l.append((v, dist[v]))\\n g.add_vertex(vertex.Vertex(v, {\\\"WEIGHT\\\": dist[v]}))\\n g.add_edge(edge.Edge(u, v, {\\\"WEIGHT\\\": dist[v]}))\\n\\n return g\",\n \"def _get_allow_all_flows() -> List[FlowDescription]:\\n return [\\n # Set flow match for all packets\\n # Don't set the app_name field\\n FlowDescription( # uplink flow\\n match=FlowMatch(\\n direction=FlowMatch.Direction.Value(\\\"UPLINK\\\"),\\n ),\\n action=FlowDescription.Action.Value(\\\"PERMIT\\\"),\\n ),\\n FlowDescription( # downlink flow\\n match=FlowMatch(\\n direction=FlowMatch.Direction.Value(\\\"DOWNLINK\\\"),\\n ),\\n action=FlowDescription.Action.Value(\\\"PERMIT\\\"),\\n ),\\n ]\",\n \"def generate(\\n self,\\n num_nodes_src_set: int,\\n num_nodes_dst_set: int,\\n num_edges_src_dst: int,\\n num_edges_dst_src: int,\\n is_directed: bool,\\n return_node_ids: bool = False,\\n transform_graph: bool = True,\\n *args,\\n **kwargs,\\n ):\\n raise NotImplementedError()\",\n \"def _pfs_nodes(cls, graph, source, size, priority):\\n if size < 1:\\n return iter(())\\n\\n # use min-heap to implement (max) priority queue\\n # use insertion order to break priority tie\\n queue = []\\n counter = itertools.count()\\n push = lambda priority, node: heappush(queue, (-priority, next(counter), node))\\n pop = partial(heappop, queue)\\n\\n visited = set()\\n enqueued = set()\\n push(priority(source), source)\\n\\n while queue and len(visited) < size:\\n _, _, node = pop()\\n\\n if node in visited:\\n continue\\n\\n visited.add(node)\\n\\n for neighbor in graph[node]:\\n if neighbor not in enqueued:\\n enqueued.add(neighbor)\\n push(priority(neighbor), neighbor)\\n\\n return iter(visited)\",\n \"def stochastic_event_set(\\n sources, source_site_filter=filters.source_site_noop_filter):\\n for source, s_sites in source_site_filter(sources):\\n try:\\n for rupture in source.iter_ruptures():\\n for i in range(rupture.sample_number_of_occurrences()):\\n yield rupture\\n except Exception as err:\\n etype, err, tb = sys.exc_info()\\n msg = 'An error occurred with source id=%s. Error: %s'\\n msg %= (source.source_id, str(err))\\n raise_(etype, msg, tb)\",\n \"def get_flows(self, x):\\n if self.pa_frames == 2:\\n flows_backward, flows_forward = self.get_flow_2frames(x)\\n elif self.pa_frames == 4:\\n flows_backward_2frames, flows_forward_2frames = self.get_flow_2frames(x)\\n flows_backward_4frames, flows_forward_4frames = self.get_flow_4frames(flows_forward_2frames, flows_backward_2frames)\\n flows_backward = flows_backward_2frames + flows_backward_4frames\\n flows_forward = flows_forward_2frames + flows_forward_4frames\\n elif self.pa_frames == 6:\\n flows_backward_2frames, flows_forward_2frames = self.get_flow_2frames(x)\\n flows_backward_4frames, flows_forward_4frames = self.get_flow_4frames(flows_forward_2frames, flows_backward_2frames)\\n flows_backward_6frames, flows_forward_6frames = self.get_flow_6frames(flows_forward_2frames, flows_backward_2frames, flows_forward_4frames, flows_backward_4frames)\\n flows_backward = flows_backward_2frames + flows_backward_4frames + flows_backward_6frames\\n flows_forward = flows_forward_2frames + flows_forward_4frames + flows_forward_6frames\\n return flows_backward, flows_forward\",\n \"def ssf(n, N_max = 6, E_max = 4, time_total = 100 ):\\n\\n G = nx.DiGraph()\\n G.add_edge( 0, 1, time_stamp = 1)\\n\\n # List of existing nodes, with nodes repeated once for each adjacent edge\\n repeated_nodes = [0, 1]\\n\\n # compute discrete bins for nodes \\n DistNodes = _get_distribution( N_max, 0 )\\n # compute discrete bins for edges\\n DistLinks = _get_distribution( E_max, 1 )\\n \\n # Start adding the other n - 2 nodes.\\n N_current = time_current = 2\\n while N_current < n and time_current < time_total + 1:\\n # preferential attachment\\n N_current = _preferential_attachment( DistNodes, DistLinks, N_current,\\n time_total, time_current, n, repeated_nodes, G )\\n time_current += 1\\n \\n# print(time_current, N_current)\\n return G\",\n \"def get_all_network_graphs(list_mtfs):\\n list_graphs = []\\n \\n for mtf in list_mtfs:\\n list_graphs.append(get_network_graph(mtf))\\n \\n return list_graphs\",\n \"def sources(self):\\n if self.rank < self.midpoint:\\n partner = self.midpoint + (self.rank - self.left)\\n if self.rank == self.midpoint - 1 and partner == self.right:\\n partners = set()\\n elif self.rank == self.midpoint - 1 and partner == self.right - 2:\\n partners = {partner, partner + 1}\\n else:\\n partners = {partner}\\n else:\\n partner = self.left + (self.rank - self.midpoint)\\n if self.rank == self.right - 1 and partner == self.midpoint:\\n partners = set()\\n elif self.rank == self.right - 1 and partner == self.midpoint - 2:\\n partners = {partner, partner + 1}\\n else:\\n partners = {partner}\\n\\n return partners\",\n \"def update_flow(self):\\n N = len(self.vertices)\\n _vertices = self.vertices+['_source', '_sink']\\n s, t = _vertices.index('_source'), _vertices.index('_sink')\\n cost, capacity = dok_matrix((N+2, N+2)), dok_matrix((N+2, N+2))\\n\\n cost[:N, :N] = self.cost\\n capacity[:N, :N] = self.upper_bound-self.lower_bound\\n # _source to main vertices\\n l_in = self.lower_bound.toarray().sum(axis=0)\\n us, = l_in.nonzero()\\n for u in us:\\n capacity[s, u] = l_in[u]\\n # main vertices to _sink\\n l_out = self.lower_bound.toarray().sum(axis=1)\\n us, = l_out.nonzero()\\n for u in us:\\n capacity[u, t] = l_out[u]\\n # sink to source\\n infinite_flow = self.upper_bound.toarray().sum()\\n capacity[_vertices.index('sink'), _vertices.index('source')] = infinite_flow\\n\\n # get a feasible flow on original graph by finding the max flow on\\n # auxiliary graph\\n aux_fg = FlowGraph(_vertices, cost, capacity, True)\\n aux_fg.FordFulkerson()\\n assert aux_fg.residual[s].toarray().sum()==0, 'feasible flow within bounds not found'\\n\\n self.residual = aux_fg.residual[:N, :N]\\n s, t = self.vertices.index('source'), self.vertices.index('sink')\\n self.residual[s, t] = 0\\n self.residual[t, s] = 0\\n\\n self.FordFulkerson()\",\n \"def bfs(graph, source):\\n visited = [False] * len(graph.graph)\\n print(visited)\\n\\n result = \\\"\\\"\\n queue = []\\n\\n queue.append(source)\\n visited[source] = True\\n\\n while queue:\\n source = queue.pop(0)\\n result += str(source)\\n\\n while graph.graph[source] is not None:\\n data = graph.graph[source].vertex\\n if not visited[data]:\\n queue.append(data)\\n visited[data] = True\\n graph.graph[source] = graph.graph[source].next\\n return result\",\n \"def multipleTravellingSalesmen(self, iterations=None):\\n if not iterations:\\n iterations = self.mTSPIterations\\n\\n # Randomly select points drawn from unvisited and distribute equally among the ships\\n paths = self.partition(self.unvisited.keys(), len(self.ships))\\n [path.append(ship) for path, ship in zip(paths, self.ships)]\\n\\n # Run single travelling salesman on each of the ships\\n paths = [self.singleTravellingSalesman(path, iterations=0) for path in paths]\\n\\n\\n # IF TWO OR MORE SHIPS!!!\\n # Point exchange between ships and rerun tsp on each ship\\n if len(self.ships) > 1:\\n for _ in range(iterations):\\n twopathindices = random.sample(xrange(len(paths)), 2)\\n newtwopaths = self.swapTwoPointsBetweenPaths([paths[index] for index in twopathindices])\\n newtwopaths = [self.singleTravellingSalesman(path, iterations=max(len(path), 100)) for path in\\n newtwopaths]\\n if self.totalPathDistance(newtwopaths) < self.totalPathDistance(\\n [paths[index] for index in twopathindices]):\\n for i, index in enumerate(twopathindices):\\n paths[index] = newtwopaths[i]\\n\\n return paths\",\n \"def sg_hops (self):\\n return (link for s, d, link in self.network.edges_iter(data=True) if\\n link.type == Link.SG)\",\n \"def _bfs_nodes(cls, graph, source, size, **kwargs):\\n if size < 1:\\n return iter(())\\n\\n return itertools.chain(\\n (source,),\\n itertools.islice((v for u, v in nx.bfs_edges(graph, source)), size-1)\\n )\",\n \"def find_all_cycles(s,graph):\\n\\n grph = u.edge_to_list_dict(graph)\\n node_cnt = len(grph)\\n k = z.Int(\\\"k\\\")\\n syms = [z.Int('node%s'%i) for i in range(node_cnt)]\\n\\n # s.add(syms[0] == 0) # start node is a 0\\n s.add(k < node_cnt)\\n s.add(k > 1)\\n\\n o = z.Optimize()\\n\\n # for source, sinks in sgraph.s_adj_list():\\n for i in range(node_cnt):\\n s.add(syms[i] >= 0)\\n s.add(syms[i] <= k)\\n s.add(z.Or([syms[j] == ((syms[i] + 1) % k) for j in grph[i]]) == (syms[i] == 0))\\n\\n\\n r = []\\n m = []\\n\\n # o.minimize(z.Sum([syms[i] for i in range(node_cnt)]))\\n s.add(z.Product([syms[i] for i in range(node_cnt)]) == 0)\\n done = False\\n while not done:\\n if s.check() == z.sat:\\n m = s.model()\\n r.append(m)\\n s.add(k != m[k])\\n else:\\n done = True\\n\\n return r\",\n \"def get_weight_from_minflow(self):\\n start_nodes = []\\n end_nodes = []\\n capacities = []\\n unit_costs = []\\n A = 0\\n s_prime = self.sink() + 1\\n t_prime = self.sink() + 2\\n x = self.sink() + 3\\n # for every edge in the graph, add edge to mincost flow instance with\\n # infinite capacity and cost 1\\n # also add backwards edge\\n for arc in self.arc_info.keys():\\n # forward edge\\n start_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"start\\\"],\\n self.arc_info[arc][\\\"destin\\\"]))\\n # backward edge\\n start_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n capacities.append(int(self.arc_info[arc][\\\"weight\\\"])) # no negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"destin\\\"],\\n self.arc_info[arc][\\\"start\\\"]))\\n # add (x,s) and (t,x) edges with same cap, cost as above\\n in_weight_x = 0\\n for in_arc in self.in_arcs_lists[self.sink()]:\\n in_weight_x += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight_x = 0\\n for out_arc in self.out_arcs_lists[self.source()]:\\n out_weight_x += self.arc_info[out_arc][\\\"weight\\\"]\\n # (x,s)\\n start_nodes.append(x)\\n end_nodes.append(self.source())\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.source()))\\n # backward\\n start_nodes.append(self.source())\\n end_nodes.append(x)\\n capacities.append(int(out_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.source(),\\n x))\\n # (t,x)\\n start_nodes.append(self.sink())\\n end_nodes.append(x)\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.sink(),\\n x))\\n # backward\\n start_nodes.append(x)\\n end_nodes.append(self.sink())\\n capacities.append(int(in_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.sink()))\\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\\n # and cost 0.\\n for v in self:\\n # process internal verts only, since we assume source and sink have\\n # no in and out edges respectively\\n if v != self.source() and v != self.sink():\\n # compute a-exc(v)\\n in_weight = 0\\n for in_arc in self.in_arcs_lists[v]:\\n in_weight += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight = 0\\n for out_arc in self.out_arcs_lists[v]:\\n out_weight += self.arc_info[out_arc][\\\"weight\\\"]\\n a_exc = out_weight - in_weight\\n if a_exc < 0:\\n # add edge (s', v)\\n start_nodes.append(s_prime)\\n end_nodes.append(v)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n v,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (v, t')\\n start_nodes.append(v)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n v,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # process x node\\n a_exc = out_weight_x - in_weight_x\\n if a_exc < 0:\\n # add edge (s', x)\\n start_nodes.append(s_prime)\\n end_nodes.append(x)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n x,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (x, t')\\n start_nodes.append(x)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n x,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # we must send flow of A from s_prime to t_prime\\n supplies = [0]*(len(self) + 3)\\n supplies[s_prime] = int(A)\\n supplies[t_prime] = int(-A)\\n # Instantiate a SimpleMinCostFlow solver.\\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\\n # Add each arc.\\n for i in range(len(start_nodes)):\\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\\n end_nodes[i], capacities[i], unit_costs[i])\\n # Add node supplies\\n for i in range(0, len(supplies)):\\n min_cost_flow.SetNodeSupply(i, supplies[i])\\n # Find the minimum cost flow between node s' and t'.\\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\\n print('Minimum cost:', min_cost_flow.OptimalCost())\\n print('')\\n print(' Arc Flow / Capacity Cost')\\n for i in range(min_cost_flow.NumArcs()):\\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\\n print('%1s -> %1s %3s / %3s %3s' % (\\n min_cost_flow.Tail(i),\\n min_cost_flow.Head(i),\\n min_cost_flow.Flow(i),\\n min_cost_flow.Capacity(i),\\n cost))\\n # update arcs\\n start = min_cost_flow.Tail(i)\\n destin = min_cost_flow.Head(i)\\n if start != s_prime and \\\\\\n start != t_prime and \\\\\\n start != x and \\\\\\n destin != s_prime and \\\\\\n destin != t_prime and \\\\\\n destin != x:\\n # if forward, increase flow. otherwise decrease.\\n print(\\\"Processing edge ({}, {})\\\".format(start, destin))\\n if start < destin:\\n sup_flow = min_cost_flow.Flow(i)\\n else:\\n sup_flow = -min_cost_flow.Flow(i)\\n temp_start = start\\n start = destin\\n destin = temp_start\\n print(\\\"Has become ({}, {}) with sup {}\\\".format(start,\\n destin,\\n sup_flow))\\n arc = self.get_arc(start, destin)\\n if (sup_flow != 0) or (\\\"lower_bound\\\" not in \\\\\\n self.arc_info[arc].keys()):\\n print(\\\"We should add this\\\")\\n old_flow = self.arc_info[arc][\\\"weight\\\"]\\n new_flow = old_flow + sup_flow\\n self.arc_info[arc][\\\"weight\\\"] = int(new_flow)\\n print(\\\"Edge ({},{}) weight is changed from {} to {}\\\".format(\\n start,\\n destin,\\n old_flow,\\n new_flow))\\n else:\\n print('There was an issue with the min cost flow input.')\\n #self.check_conservation_of_flow() # check that solution is valid\",\n \"def dfs_r(self, s):\\n g = Graph(attr={DIRECTED: True})\\n return self.dfs_rec(g, ('#', s))\",\n \"def _ppsc_gossip(self):\\n for i in range(self.s):\\n for edges in self.all_edges:\\n # for each connected component\\n selected_edge = random.choice(edges)\\n self._ppsc_gossip_edge(selected_edge)\",\n \"def flows(self, flows):\\n\\n self._flows = flows\",\n \"def get_reachable_nodes(self, source: Node) -> Set[Node]:\\n nodes_found: Set[Node] = {source}\\n queue = [source]\\n while queue:\\n v = queue.pop()\\n for e in v.outgoing_edges:\\n if e.node_to not in nodes_found:\\n nodes_found.add(e.node_to)\\n queue.append(e.node_to)\\n return nodes_found\",\n \"def gen_flows_from_choice(choice, flow_event_model, choice_stocks):\\n rv = []\\n i = 0\\n try:\\n while(True):\\n up = choice[i+1]\\n down = choice[i]\\n up_stock_slug = up[0]\\n down_stock_slug = down[0]\\n up_slug = \\\"rising_%s\\\" % up_stock_slug\\n up_name = \\\"Rising to %s\\\" % up[1].lower()\\n down_slug = \\\"dropping_%s\\\" % down_stock_slug\\n down_name = \\\"Dropping to %s\\\" % down[1].lower()\\n rv.append(Flow(slug=up_slug, name=up_name, flow_event_model=flow_event_model,\\n sources=[choice_stocks[down_stock_slug]],\\n sinks=[choice_stocks[up_stock_slug]]))\\n rv.append(Flow(slug=down_slug, name=down_name, flow_event_model=flow_event_model,\\n sources=[choice_stocks[up_stock_slug]],\\n sinks=[choice_stocks[down_stock_slug]]))\\n i += 1\\n except IndexError:\\n pass\\n return rv\",\n \"def run(graph: Graph) -> List[Edge]:\\n edges = sorted(WeightedEdge(edge) for edge in graph.get_edges())\\n partitions = UnionFind()\\n mst = []\\n\\n for edge in edges:\\n added = partitions.union(edge.source, edge.target)\\n if added:\\n mst.append(edge._edge)\\n\\n if len(mst) == graph.get_number_of_nodes() - 1:\\n break\\n\\n return mst\",\n \"def max_flow(self, source, sink):\\n\\n max_flow = 0\\n\\n for i in range(self.V):\\n for j in range(self.V):\\n self.flow[i, j] = 0\\n\\n while self.bfs(source, sink):\\n increment = maxint\\n\\n u = sink\\n\\n while self.pred[u] != -1:\\n increment = min(\\n increment, self.capacity[self.pred[u], u] - self.flow[self.pred[u], u])\\n u = self.pred[u]\\n\\n u = sink\\n\\n while self.pred[u] != -1:\\n self.flow[self.pred[u], u] += increment\\n self.flow[u, self.pred[u]] -= increment\\n u = self.pred[u]\\n\\n max_flow += increment\\n\\n return max_flow\",\n \"def bfs(self, starting_vertex, destination_vertex):\\n visited = set()\\n paths = [[starting_vertex]]\\n \\\"\\\"\\\"\\n For every list in paths. If the last item in the list is \\n the destination return the list. If the last item is not \\n in the visited cache add it and make a new path for all \\n of it's edges. If the last item has been visited remove \\n it from the paths list.\\n \\\"\\\"\\\"\\n for path in paths:\\n vertex = path[-1]\\n if vertex == destination_vertex:\\n return path\\n if vertex not in visited:\\n visited.add(vertex)\\n for key in self.get_neighbors(vertex):\\n newPath = path + [key]\\n paths.append(newPath)\",\n \"def get_all_social_paths(self, user_id): #each user v v each path V V\\n # output example- {1: [1], 8: [1, 8], 10: [1, 10], 5: [1, 5], 2: [1, 10, 2], 6: [1, 10, 6], 7: [1, 10, 2, 7]}\\n visited = {} # Note that this is a dictionary, not a set\\n # Need to do a bfs using the user id\\n # first step is to traverse the graph and record all the vertices as keys in visited using bft\\n # then take those keys and use bfs on each, using user_id as the starting node and and the key as\\n # the destination node\\n\\n # Modification of BFT\\n # create an empty dict\\n # q = Queue()\\n q = []\\n\\n # init enqueue the starting node\\n q.append(user_id)\\n\\n while len(q) > 0:\\n # Dequeue the first item\\n v = q.pop(0)\\n # If it's not been visited:\\n if v not in visited:\\n # Mark as visited (i.e. add to the visited set)\\n visited[v] = []\\n\\n # Do something with the node\\n print(f\\\"Visited {v}\\\")\\n\\n # Add all neighbors to the queue\\n for next_vert in self.friendships[v]:\\n q.append(next_vert)\\n\\n # once visited is filled, then we start the bfs\\n #print('vv',visited)\\n possible_paths = {}\\n #run a bfs for each key in visited\\n for v in visited:\\n possible_paths[v] = []\\n \\n if v == user_id:\\n visited[v] = [user_id]\\n\\n path = []\\n while len(path) < len(visited):\\n\\n # Add all neighbors to the queue\\n for next_vert in self.friendships[v]:\\n print(possible_paths[v])\\n # copy the path\\n # temp_path = list(path)\\n # temp_path.append(next_vert)\\n # add path to possible_paths\\n path.append(next_vert)\\n\\n possible_paths[v].append(path) # HAVE TO USE QUEUE OR STACK, THEY ENSURE THE NEIGHBORS\\n # FOLLOW THE CORRECT ORDER WHEN LOOPING \\n\\n if v == path[-1]:\\n \\n # IF SO, RETURN PATH\\n visited[v] = path\\n break\\n\\n # for x in visited:\\n # bfs(user_id, x)\\n # visited[x].add(path)\\n \\n print('pct of total users in network', len(visited[1])/len(visited))\\n print('degrees of separation', len(visited[1]) - 1)\\n return visited\",\n \"def sens_flow_jsons(contexts: [{}], filter_flow) -> []:\\n jsons = []\\n for context in contexts:\\n context_dir = context['dir']\\n logger.debug(context_dir)\\n for root, dirs, files in os.walk(context_dir):\\n for file in files:\\n if not file.endswith('_sens_http_flows.json'):\\n continue\\n with open(os.path.join(root, file), 'r', encoding=\\\"utf8\\\", errors='ignore') as infile:\\n flows = json.load(infile)\\n for flow in flows:\\n if not filter_flow(flow):\\n # The ground truth label, which is defined by \\\"context\\\" label.\\n flow['real_label'] = context['label']\\n jsons.append(flow)\\n logger.info('The number of flows: %d', len(jsons))\\n return jsons\",\n \"def _get_staples(self, site, u, links=None):\\n if links is None:\\n links = self.links\\n if len(links.shape) == 1:\\n links = tf.reshape(links, self.links.shape)\\n\\n shape = self.site_idxs\\n\\n staples = []\\n for v in range(self.dim): # u, v instead of mu, nu for readability\\n if v != u:\\n l1 = self.get_link(site + self.bases[u], v, shape, links)\\n l2 = self.get_link(site + self.bases[v], u, shape, links)\\n l3 = self.get_link(site, v, shape, links)\\n\\n l4 = self.get_link(site + self.bases[u] - self.bases[v],\\n v, shape, links)\\n l5 = self.get_link(site - self.bases[v], u, shape, links)\\n l6 = self.get_link(site - self.bases[v], v, shape, links)\\n\\n if self.link_type == 'U1':\\n _sum1 = l1 - l2 - l3\\n _sum2 = -l4 -l5 + l6\\n\\n elif self.link_type in ['SU2', 'SU3']:\\n prod1 = tf.matmul(l1, mat_adj(l2))\\n prod1 = tf.matmul(prod1, mat_adj(l3))\\n\\n prod2 = tf.matmul(mat_adj(l3), mat_adj(l4))\\n prod2 = tf.matmul(prod2, mat_adj(l6))\\n\\n _sum = prod1 + prod2\\n\\n #_arr = [_sum1, _sum2]\\n staples.append(_sum1)\\n staples.append(_sum2)\\n\\n return staples\",\n \"def flow_graph_hash(graph):\\n assert isinstance(graph, BasicGraph)\\n sources = graph.nodes(in_degree=0)\\n\\n original_hash = 'original hash'\\n new_hash = 'new_hash'\\n cls = type(graph)\\n hash_graph = cls() # new graph with hashes.\\n visited = set()\\n\\n while sources:\\n source = sources[0]\\n sources = sources[1:]\\n\\n suppliers = graph.nodes(to_node=source)\\n\\n hash_func = hashlib.sha3_256()\\n hash_func.update(bytes(str(source), 'utf-8'))\\n for supplier in suppliers:\\n if graph.depth_first_search(start=source, end=supplier):\\n continue # it's a cycle.\\n d = hash_graph.node(supplier)\\n hash_func.update(bytes(d[new_hash], 'utf-8'))\\n source_hash = hash_func.hexdigest()\\n\\n if source not in hash_graph:\\n obj = {original_hash: source, new_hash: source_hash}\\n hash_graph.add_node(source, obj=obj)\\n else:\\n n = hash_graph.node(source)\\n n[new_hash] = source_hash\\n\\n receivers = graph.nodes(from_node=source)\\n for receiver in receivers:\\n if receiver in visited:\\n continue\\n visited.add(receiver)\\n\\n if receiver not in hash_graph:\\n obj = {original_hash: receiver, new_hash: None}\\n hash_graph.add_node(node_id=receiver, obj=obj)\\n hash_graph.add_edge(source, receiver)\\n if receiver not in sources:\\n sources.append(receiver)\\n\\n for sink in graph.nodes(out_degree=0):\\n n = hash_graph.node(sink)\\n assert n[new_hash] is not None, n\\n\\n return hash_graph\",\n \"def run_dfs(self,s):\\n if self.verbose: print('entering run_dfs with s = ',s)\\n new_states = [self.succ(s,a) for a in self.actions(s)]\\n results = []\\n\\n for ns in new_states:\\n if self.verbose: print('considering new state = ',ns)\\n end = self.is_end(ns)\\n if end:\\n result = self.result(ns)\\n if result is not None:\\n results.append(result)\\n else:\\n results += self.run_dfs(ns)\\n return results\",\n \"def compute_flow(self, loads):\\n assert len(loads) == self.n_nodes\\n flow = np.zeros([self.n_nodes, self.n_nodes])\\n for k, l in self.lines:\\n flow[k, l] = self.line_flow(k, l, loads)\\n return flow\",\n \"def bfsSample(G, source=None, k = 50):\\n\\twarn(\\\"networkit.sampling.bfsSample is deprecated, will be removed in future updates.\\\")\\n\\tif not source:\\n\\t\\tsource = GraphTools.randomNode(G)\\n\\tn = G.numberOfNodes()\\n\\tvisited = [False]*n\\n\\tQ = [source]\\n\\tclosest = set([source])\\n\\tglobal found\\n\\tfound = 0\\n\\twhile len(Q) > 0 and found < k:\\n\\t\\tu = Q.pop(0)\\n\\t\\tdef enqueue(u,v,weight, eid):\\n\\t\\t\\tglobal found\\n\\t\\t\\tif not visited[v] and found < k:\\n\\t\\t\\t\\tfound += 1\\n\\t\\t\\t\\tvisited[v] = True\\n\\t\\t\\t\\tQ.append(v)\\n\\t\\t\\t\\tclosest.add(v)\\n\\t\\tG.forEdgesOf(u, enqueue)\\n\\tprint(\\\"found {0} nodes\\\".format(len(closest)))\\n\\tG1 = GraphTools.subgraphFromNodes(G, closest)\\n\\treturn G1\",\n \"def shortest_flight(self):\\r\\n distance = sys.maxsize\\r\\n for code, _list in self.edges.items():\\r\\n for edge in _list:\\r\\n if edge.distance < distance:\\r\\n distance = edge.distance\\r\\n start = edge.start\\r\\n destination = edge.destination\\r\\n return start, destination, distance\",\n \"def shortestPath(self, source, target):\\n dist = {}\\n prev = {}\\n q = []\\n for y,a in enumerate(self.sm):\\n for x,b in enumerate(self.sm[y]):\\n dist[(x,y)] = sys.maxint\\n prev[(x,y)] = None\\n q.append((x,y))\\n dist[source] = 0\\n\\n while len(q) is not 0:\\n # find the node with minimum value (u)\\n d = deepcopy(dist)\\n while True:\\n b = dict(map(lambda item: (item[1],item[0]), d.items()))\\n u = b[min(b.keys())]\\n if u not in q:\\n d.pop(u)\\n else:\\n break\\n\\n if dist[u] == sys.maxint: # remaining nodes are inaccessible\\n break\\n\\n q.remove(u)\\n\\n\\n if u == target: # target found\\n break\\n\\n for v in self.getNeighbors(u):\\n alt = dist[u] + 1\\n if alt < dist[v]:\\n dist[v] = alt\\n prev[v] = u\\n\\n s = []\\n u = target\\n while prev[u] is not None:\\n s.append(u)\\n u = prev[u]\\n s.reverse()\\n\\n return s\",\n \"def bfs_nodes_generator(graph, source, reverse=...):\\n ...\",\n \"def gen_task_sets_fairgen(nsets):\\n start = time()\\n eval_task_sets = []\\n for util in utils:\\n task_sets = []\\n for i in range(nsets):\\n ts = synth.mc_fairgen(set_id=i, u_lo=util, implicit_deadlines=True)\\n synth.synth_c_pmf(ts)\\n synth.set_fixed_priorities(ts)\\n task_sets.append(ts)\\n eval_task_sets.append(task_sets)\\n stop = time()\\n print('Task Set Generation MC-Fairgen: %.3fs' % (stop - start))\\n pickle.dump(eval_task_sets, open(task_sets_path + 'task_sets_fairgen', 'wb'))\",\n \"def shiftFlows(self, targetFlows, stepSize):\\n for l in self.link:\\n current = self.link[l].flow\\n target = targetFlows[l]\\n new = current *(1 - stepSize)+target*stepSize\\n self.link[l].flow = new\\n self.link[l].updateCost()\",\n \"def Run(self):\\r\\n # start all the flows along with updating related flow's transfer time\\r\\n while self.sched.toStartFlows:\\r\\n # the first flow is with earliest startTime\\r\\n curStartFlow = self.sched.toStartFlows[0]\\r\\n # update flows if there are flows has already finished\\r\\n while self.sched.runningFlows:\\r\\n # the first flow is with earliest finishTime\\r\\n toFinishFlow = self.sched.runningFlows[0]\\r\\n\\r\\n if toFinishFlow.finishTime <= curStartFlow.startTime:\\r\\n # remove this flow from running flows\\r\\n self.sched.runningFlows.remove(toFinishFlow)\\r\\n # add this flow to finished flows\\r\\n self.sched.finishedFlows.append(toFinishFlow)\\r\\n # Update related flow's transfer time in removing a flow\\r\\n self.sched.UpdateFlow(toFinishFlow, \\\"remove\\\")\\r\\n # Resort runningFlows by endTime\\r\\n self.sched.runningFlows.sort(key=lambda x: x.finishTime)\\r\\n else:\\r\\n break\\r\\n # insert current start flow to running list\\r\\n self.sched.runningFlows.append(curStartFlow)\\r\\n # Update related flow's transfer time in removing a flow\\r\\n self.sched.UpdateFlow(curStartFlow, \\\"insert\\\")\\r\\n # Resort runningFlows by endTime\\r\\n self.sched.runningFlows.sort(key=lambda x: x.finishTime)\\r\\n # remove this flow from start list\\r\\n self.sched.toStartFlows.remove(curStartFlow)\\r\\n\\r\\n # Now, all the flows are started\\r\\n # Iteratively update flow's transfer time in running list until all the flows are finished\\r\\n while self.sched.runningFlows:\\r\\n # the first flow is always with earliest finish Time\\r\\n curFinishFlow = self.sched.runningFlows[0]\\r\\n\\r\\n # remove it from running list\\r\\n self.sched.runningFlows.remove(curFinishFlow)\\r\\n # insert it to finished flows\\r\\n self.sched.finishedFlows.append(curFinishFlow)\\r\\n # Update related flow's transfer time in removing a flow\\r\\n self.sched.UpdateFlow(curFinishFlow, \\\"remove\\\")\\r\\n # Resort runningFlows by endTime\\r\\n self.sched.runningFlows.sort(key=lambda x: x.finishTime)\\r\\n\\r\\n # Finally, all the flows are finished\\r\\n self.sched.PrintFlows()\",\n \"def flow_model():\\n return {\\n 'nodes': [\\n {\\n 'id': 'left_root',\\n 'name': 'left_root',\\n 'value': 3.5,\\n 'rank': 'l',\\n },\\n {\\n 'id': 'right_root',\\n 'name': 'right_root',\\n 'value': 3.5,\\n 'rank': 'r',\\n },\\n ], 'edges': [\\n {\\n 'source': 'left_root',\\n 'target': 'right_root',\\n 'value': 1.0,\\n },\\n ]\\n }\",\n \"def dfs(self, starting_vertex, destination_vertex):\\n # create an empty stack \\n stack = Stack()\\n #push the starting vertex ID as list\\n stack.push([starting_vertex])\\n # create an empty Set to store the visited vertices\\n visited = set()\\n # while the stack is not empty ...\\n while stack.size() > 0:\\n # pop the first vertex\\n path = stack.pop()\\n vert = path[-1]\\n # if that vertex has not been visited ..\\n if vert not in visited:\\n #check for target\\n if vert == destination_vertex:\\n return path\\n # mark it is visited\\n visited.add(vert)\\n # then add all of its neighbors to the top of the stack\\n for neighbor in self.vertices[vert]: #self.get_neighbors(vert)\\n #copy path to avoid pass by reference\\n new_path = list(path) # make a copy\\n new_path.append(neighbor)\\n stack.push(new_path)\",\n \"def get_segments(self, sets=None):\\n if sets is None:\\n if self.sets is not None:\\n sets = self.sets\\n else:\\n raise ValueError(\\\"sets and self.sets attributes are None, \\\\\\n you need either to pass an origin argument to get_segments or \\\\\\n to use get_filtration method before\\\")\\n segments = []\\n for s in sets:\\n if self.epsilon <= s.getRelevance():\\n t, a, b = s.getPosition()\\n for i, seg in enumerate(segments):\\n tp, ap, bp = seg\\n if t >= tp and bp > a:\\n bp = a\\n elif t <= tp and ap < b:\\n ap = b\\n segments[i] = (tp, ap, bp)\\n segments.append((t, a, b))\\n return segments\",\n \"def sources(self):\\n s = [node for node in self.nodes() if node.isSource()]\\n s.sort(lambda x,y: cmp(x._id, y._id))\\n return s\",\n \"def get_flowgram_distances_on_cluster(\\r\\n id, flowgram, flowgrams, fc, ids, num_cores,\\r\\n num_flows, spread, client_sockets=[]):\\r\\n epoch = time()\\r\\n\\r\\n check_flowgram_ali_exe()\\r\\n\\r\\n qiime_config = load_qiime_config()\\r\\n min_per_core = int(qiime_config['denoiser_min_per_core'])\\r\\n # if using from future import division this has to be checked,\\r\\n # as we want true integer division here\\r\\n\\r\\n per_core = max(min_per_core, (num_flows / num_cores) + 1)\\r\\n names = []\\r\\n scores = []\\r\\n\\r\\n # Need to call this here, since we iterate over the same iterator repeatedly.\\r\\n # Otherwise the call in ifilter will reset the iterator by implicitely calling __iter__.\\r\\n # test if iter does the same\\r\\n flowgrams_iter = flowgrams.__iter__()\\r\\n # prepare input files and commands\\r\\n # synchronous client-server communication\\r\\n\\r\\n workload = compute_workload(num_cores, num_flows, spread)\\r\\n\\r\\n debug_count = 0\\r\\n for i in range(num_cores):\\r\\n socket = client_sockets[i]\\r\\n # send master flowgram to file first\\r\\n send_flowgram_to_socket(id, flowgram, socket)\\r\\n\\r\\n if(workload[i] < 1):\\r\\n # no data left for this poor guy\\r\\n save_send(socket, \\\"--END--\\\")\\r\\n continue\\r\\n else:\\r\\n # Then add all others which are still valid, i.e. in ids\\r\\n for (k, f) in (izip(range(workload[i]),\\r\\n ifilter(lambda f: f.Name in ids, flowgrams_iter))):\\r\\n fc.add(f)\\r\\n send_flowgram_to_socket(k, f, socket, trim=False)\\r\\n names.append(f.Name)\\r\\n debug_count += 1\\r\\n # send the termination signal\\r\\n save_send(socket, \\\"--END--\\\")\\r\\n\\r\\n # asynchronous client-server communication\\r\\n # ClientHandlers write data in results\\r\\n results = [None] * num_cores\\r\\n timing = [0.0 for x in xrange(num_cores)]\\r\\n for i in range(num_cores):\\r\\n socket = client_sockets[i]\\r\\n ClientHandler(socket, i, results, timing)\\r\\n loop()\\r\\n # end asynchronous loop\\r\\n\\r\\n spread = adjust_processing_time(num_cores, workload, timing, epoch)\\r\\n\\r\\n # flatten list\\r\\n scores = [item for list in results for item in list]\\r\\n\\r\\n if (debug_count != len(scores)):\\r\\n raise RuntimeError(\\\"Something bad has happened! I received less \\\" +\\r\\n \\\"alignment scores %d than there are flowgrams %d. Most likely this \\\"\\r\\n % (len(scores), debug_count) +\\r\\n \\\"means that the alignment program is not setup correctly or corrupted. \\\" +\\r\\n \\\"Please run the test scripts to figure out the cause of the error.\\\")\\r\\n\\r\\n return (scores, names, fc)\",\n \"def bfs_edges_generator(graph, source, reverse=...):\\n ...\",\n \"def __dynamicThroughput( self, sourceSEs, destSEs ):\\n res = self.__getTimeToStart()\\n if not res['OK']:\\n gLogger.error( res['Message'] )\\n return {}\\n channelInfo = res['Value']\\n\\n timeToSite = {} # Maintains time to site including previous hops\\n siteAncestor = {} # Maintains the ancestor channel for a site\\n tree = {} # Maintains replication tree\\n while len( destSEs ) > 0:\\n minTotalTimeToStart = float( \\\"inf\\\" )\\n candidateChannels = []\\n sourceActiveSEs = self.__getActiveSEs( sourceSEs )\\n for destSE in destSEs:\\n destSites = self.__getChannelSitesForSE( destSE )\\n localTransfer = False\\n for destSite in destSites:\\n if localTransfer: break\\n for sourceSE in sourceActiveSEs:\\n if localTransfer: break\\n sourceSites = self.__getChannelSitesForSE( sourceSE )\\n for sourceSite in sourceSites:\\n if localTransfer: break\\n channelName = '%s-%s' % ( sourceSite, destSite )\\n if channelInfo.has_key( channelName ):\\n channelID = channelInfo[channelName]['ChannelID']\\n if tree.has_key( channelID ):\\n continue\\n channelTimeToStart = channelInfo[channelName]['TimeToStart']\\n if timeToSite.has_key( sourceSE ):\\n totalTimeToStart = timeToSite[sourceSE] + channelTimeToStart + self.sigma\\n else:\\n totalTimeToStart = channelTimeToStart\\n #print '%s-%s %s %s' % (sourceSE,destSE,channelTimeToStart,totalTimeToStart)\\n localTransfer = ( sourceSite == destSite )\\n if localTransfer or totalTimeToStart < minTotalTimeToStart:\\n minTotalTimeToStart = totalTimeToStart\\n selectedPathTimeToStart = totalTimeToStart\\n candidateChannels = [( sourceSE, destSE, channelID )]\\n elif totalTimeToStart == minTotalTimeToStart:\\n candidateChannels.append( ( sourceSE, destSE, channelID ) )\\n\\n #minTotalTimeToStart = totalTimeToStart\\n #selectedPathTimeToStart = totalTimeToStart\\n #selectedSourceSE = sourceSE\\n #selectedDestSE = destSE\\n #selectedChannelID = channelID\\n else:\\n errStr = 'StrategyHandler.__dynamicThroughput: Channel not defined'\\n gLogger.warn( errStr, channelName )\\n\\n #print 'Selected %s \\\\n' % selectedPathTimeToStart\\n\\n random.shuffle( candidateChannels )\\n selectedSourceSE, selectedDestSE, selectedChannelID = candidateChannels[0]\\n timeToSite[selectedDestSE] = selectedPathTimeToStart\\n siteAncestor[selectedDestSE] = selectedChannelID\\n\\n if siteAncestor.has_key( selectedSourceSE ):\\n waitingChannel = siteAncestor[selectedSourceSE]\\n else:\\n waitingChannel = False\\n tree[selectedChannelID] = {}\\n tree[selectedChannelID]['Ancestor'] = waitingChannel\\n tree[selectedChannelID]['SourceSE'] = selectedSourceSE\\n tree[selectedChannelID]['DestSE'] = selectedDestSE\\n tree[selectedChannelID]['Strategy'] = 'DynamicThroughput'\\n sourceSEs.append( selectedDestSE )\\n destSEs.remove( selectedDestSE )\\n return tree\",\n \"def splitSources(sources: Iterable[FileId], chunkSize: int) -> List[List[FileId]]:\\n if chunkSize <= 0:\\n raise ValueError(f\\\"chunkSize must be positive ({chunkSize})\\\")\\n\\n sentinel = FileId(visit=math.nan, arm=None, spectrograph=None)\\n sources = [sentinel] + sorted(sources, key=lambda x: x.visit) + [sentinel]\\n\\n # Split sources into sequences, each contiguous in terms of visits.\\n contiguousSeqs = []\\n for iscontiguous, group in itertools.groupby(\\n zip(sources[:-1], sources[1:]),\\n key=lambda pair: pair[1].visit - pair[0].visit == 1\\n ):\\n group = list(group)\\n if iscontiguous:\\n contiguousSeqs.append([pair[0] for pair in group] + [group[-1][-1]])\\n else:\\n contiguousSeqs.extend([pair[-1]] for pair in group[:-1])\\n\\n # Further split the contiguous sequences into small chunks\\n chunks = []\\n for seq in contiguousSeqs:\\n n = len(seq)\\n numChunks = (n + chunkSize - 1) // chunkSize\\n quotient = n // numChunks\\n remainder = n % numChunks\\n for i in range(numChunks):\\n if remainder > 0:\\n remainder -= 1\\n numToPop = quotient + 1\\n else:\\n numToPop = quotient\\n chunks.append(seq[:numToPop])\\n seq = seq[numToPop:]\\n assert(len(seq) == 0)\\n\\n return chunks\",\n \"def maximum_flow(graph, start, end):\\n if not isinstance(graph, BasicGraph):\\n raise TypeError(f\\\"Expected subclass of BasicGraph, not {type(graph)}\\\")\\n Graph = type(graph)\\n \\n if start not in graph:\\n raise ValueError(f\\\"{start} not in graph\\\")\\n if end not in graph:\\n raise ValueError(f\\\"{end} not in graph\\\")\\n\\n inflow = sum(d for s, e, d in graph.edges(from_node=start))\\n outflow = sum(d for s, e, d in graph.edges(to_node=end))\\n unassigned_flow = min(inflow, outflow) # search in excess of this 'flow' is a waste of time.\\n total_flow = 0\\n # -----------------------------------------------------------------------\\n # The algorithm\\n # I reviewed a number of algorithms, such as Ford-fulkerson algorithm,\\n # Edmonson-Karp and Dinic, but I didn't like them due to their naive usage\\n # of DFS, which leads to a lot of node visits.\\n #\\n # I therefore choose to invert the capacities of the graph so that the\\n # capacity any G[u][v] = c becomes 1/c in G_inverted.\\n # This allows me to use the shortest path method to find the path with\\n # most capacity in the first attempt, resulting in a significant reduction\\n # of unassigned flow.\\n #\\n # By updating G_inverted, with the residual capacity, I can keep using the\\n # shortest path, until the capacity is zero, whereby I remove the links\\n # When the shortest path method returns 'No path' or when unassigned flow\\n # is zero, I exit the algorithm.\\n #\\n # Even on small graphs, this method is very efficient, despite the overhead\\n # of using shortest path. For very large graphs, this method outperforms\\n # all other algorithms by orders of magnitude.\\n # -----------------------------------------------------------------------\\n\\n edges = [(n1, n2, 1 / d) for n1, n2, d in graph.edges() if d > 0]\\n inverted_graph = Graph(from_list=edges) # create G_inverted.\\n capacity_graph = Graph() # Create structure to record capacity left.\\n flow_graph = Graph() # Create structure to record flows.\\n\\n while unassigned_flow:\\n # 1. find the best path\\n d, path = shortest_path(inverted_graph, start, end)\\n if d == float(\\\"inf\\\"): # then there is no path, and we must exit.\\n return total_flow, flow_graph\\n # else: use the path and lookup the actual flow from the capacity graph.\\n\\n path_flow = min([min(d, capacity_graph.edge(s, e, default=float(\\\"inf\\\"))) for s, e, d in graph.edges(path=path)])\\n\\n # 2. update the unassigned flow.\\n unassigned_flow -= path_flow\\n total_flow += path_flow\\n\\n # 3. record the flows and update the inverted graph, so that it is\\n # ready for the next iteration.\\n edges = graph.edges(path)\\n for n1, n2, d in edges:\\n # 3.a. recording:\\n v = flow_graph.edge(n1, n2, default=None)\\n if v is None:\\n flow_graph.add_edge(n1, n2, path_flow)\\n c = graph.edge(n1, n2) - path_flow\\n else:\\n flow_graph.add_edge(n1, n2, value=v + path_flow)\\n c = graph.edge(n1, n2) - (v + path_flow)\\n capacity_graph.add_edge(n1, n2, c)\\n\\n # 3.b. updating:\\n # if there is capacity left: update with new 1/capacity\\n # else: remove node, as we can't do 1/zero.\\n if c > 0:\\n inverted_graph.add_edge(n1, n2, 1 / c)\\n else:\\n inverted_graph.del_edge(n1, n2)\\n return total_flow, flow_graph\",\n \"def dfs(self, starting_vertex, destination_vertex):\\n \\\"\\\"\\\" LIFO\\n Create a stack\\n Create a set to store visited\\n PUSH starting vertex into an array (STACK)\\n While the STACK is NOT empty \\n get((pop) first PATH vertex\\n get Vertex from END of PATH\\n check if NOT visited\\n mark as visited\\n check if vertex is destination_vertex\\n If TRUE, return path \\n PUSH path to ALL of neighbors\\n make copy of current path\\n add neighbor to path copy\\n PUSH path copy\\n \\\"\\\"\\\" \\n s = Stack() # Create a stack\\n s.push([starting_vertex]) # PUSH starting vertex into an array (STACK)\\n visited = set() # Create a set to store visited\\n\\n while s.size() > 0: # While the STACK is NOT empty\\n path = s.pop() # get(pop) first PATH vertex)\\n v = path[-1] # get Vertex from END of PATH \\n\\n while v not in visited: # check if NOT visited\\n visited.add(v) # mark as visited\\n\\n if v == destination_vertex: # check if vertex is destination_vertex\\n return path # If TRUE, return path \\n\\n for n in self.get_neighbors(v): # PUSH path to ALL of neighbors\\n path_c = path[:] # make copy of current path\\n # path_c.extend([n]) # add neighbor to path copy\\n path_c.append(n) # add neighbor to path copy\\n s.push(path_c) # PUSH path copy\",\n \"def build_solution_graph(self, graph, flows, connecting_graph=False):\\n self.logger.info(\\\"Building solution graph\\\")\\n self.clean_flow_cycles(flows)\\n edges_to_keep = [e for e, flow in flows.items() if flow > 0]\\n solution_graph_mdg = graph.edge_subgraph(edges_to_keep)\\n\\n if connecting_graph:\\n # We add the edges to connect\\n edges_to_keep = edges_to_keep + self.connecting_graph(solution_graph_mdg)\\n # We rebuild the graph\\n solution_graph_mdg = graph.edge_subgraph(edges_to_keep)\\n\\n # We add the flow attribute\\n for e in edges_to_keep:\\n solution_graph_mdg.edges[(e[0], e[1], 0)][config.SOLUTION_POWER_FLOW_KEY] = flows[e]\\n\\n # We convert it in GeoDiGraph\\n solution_graph_mdg.crs = self.optimization_graph.crs\\n solution_graph = gnx.GeoDiGraph(solution_graph_mdg, crs=solution_graph_mdg.crs)\\n\\n gnx.remove_isolates(solution_graph)\\n solution_graph.name = \\\"solution_graph\\\"\\n\\n return solution_graph\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6088071","0.6088071","0.58521134","0.56622416","0.5531953","0.5518096","0.54397494","0.54385334","0.54131764","0.5411593","0.53891915","0.5348688","0.53438646","0.5327883","0.52937067","0.5290496","0.5274863","0.5273465","0.5230514","0.5225777","0.5223595","0.52171016","0.52110416","0.5210066","0.52085245","0.51111907","0.5098642","0.50985384","0.50923014","0.50914574","0.5081049","0.5072436","0.5061362","0.5061225","0.50603384","0.50569326","0.5055053","0.504692","0.5046117","0.5027933","0.5020488","0.5015148","0.49974883","0.49972102","0.49952188","0.4985148","0.49743798","0.49711978","0.49691206","0.49640983","0.49597338","0.49402034","0.49363157","0.4931727","0.49304524","0.4929002","0.49283576","0.49189827","0.4917072","0.49135643","0.489885","0.48987353","0.4895498","0.4893887","0.48858812","0.48827547","0.48793307","0.48772576","0.48767143","0.4875749","0.48710135","0.4871","0.48674884","0.48672605","0.48626885","0.4838662","0.4837683","0.48346666","0.4828607","0.4821241","0.4816403","0.48130804","0.48100975","0.4803891","0.47938254","0.47923037","0.47916782","0.4776676","0.47755882","0.47735584","0.4768982","0.4767937","0.47666836","0.47619113","0.47600076","0.47463903","0.47428417","0.47387826","0.47372273","0.47346142","0.47274128"],"string":"[\n \"0.6088071\",\n \"0.6088071\",\n \"0.58521134\",\n \"0.56622416\",\n \"0.5531953\",\n \"0.5518096\",\n \"0.54397494\",\n \"0.54385334\",\n \"0.54131764\",\n \"0.5411593\",\n \"0.53891915\",\n \"0.5348688\",\n \"0.53438646\",\n \"0.5327883\",\n \"0.52937067\",\n \"0.5290496\",\n \"0.5274863\",\n \"0.5273465\",\n \"0.5230514\",\n \"0.5225777\",\n \"0.5223595\",\n \"0.52171016\",\n \"0.52110416\",\n \"0.5210066\",\n \"0.52085245\",\n \"0.51111907\",\n \"0.5098642\",\n \"0.50985384\",\n \"0.50923014\",\n \"0.50914574\",\n \"0.5081049\",\n \"0.5072436\",\n \"0.5061362\",\n \"0.5061225\",\n \"0.50603384\",\n \"0.50569326\",\n \"0.5055053\",\n \"0.504692\",\n \"0.5046117\",\n \"0.5027933\",\n \"0.5020488\",\n \"0.5015148\",\n \"0.49974883\",\n \"0.49972102\",\n \"0.49952188\",\n \"0.4985148\",\n \"0.49743798\",\n \"0.49711978\",\n \"0.49691206\",\n \"0.49640983\",\n \"0.49597338\",\n \"0.49402034\",\n \"0.49363157\",\n \"0.4931727\",\n \"0.49304524\",\n \"0.4929002\",\n \"0.49283576\",\n \"0.49189827\",\n \"0.4917072\",\n \"0.49135643\",\n \"0.489885\",\n \"0.48987353\",\n \"0.4895498\",\n \"0.4893887\",\n \"0.48858812\",\n \"0.48827547\",\n \"0.48793307\",\n \"0.48772576\",\n \"0.48767143\",\n \"0.4875749\",\n \"0.48710135\",\n \"0.4871\",\n \"0.48674884\",\n \"0.48672605\",\n \"0.48626885\",\n \"0.4838662\",\n \"0.4837683\",\n \"0.48346666\",\n \"0.4828607\",\n \"0.4821241\",\n \"0.4816403\",\n \"0.48130804\",\n \"0.48100975\",\n \"0.4803891\",\n \"0.47938254\",\n \"0.47923037\",\n \"0.47916782\",\n \"0.4776676\",\n \"0.47755882\",\n \"0.47735584\",\n \"0.4768982\",\n \"0.4767937\",\n \"0.47666836\",\n \"0.47619113\",\n \"0.47600076\",\n \"0.47463903\",\n \"0.47428417\",\n \"0.47387826\",\n \"0.47372273\",\n \"0.47346142\",\n \"0.47274128\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24591,"cells":{"query":{"kind":"string","value":"r\"\"\" RETURNS A set of paths, P. \\forall p_i \\in P, p_i begins at s and ends at t. The set also includes the proportion of flow f that should transit each path p_i \\in P"},"document":{"kind":"string","value":"def traverse_graph(F, f, s, t, u, sr):\n def get_paths_for_flow(F, s, f):\n \"\"\"\n RETURNS\n A set of outgoing links and corresponding splitting ratios for flow f\n at node s\n \"\"\"\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links\n \n if u == t:\n return [([t], sr)]\n\n outgoing_links = get_paths_for_flow(F, u, f)\n paths_to_t = []\n\n for ((current_node, next_hop), split_ratio) in outgoing_links:\n paths_from_u_to_t = traverse_graph(F, f, s, t, next_hop, split_ratio) \n paths_to_t.extend(paths_from_u_to_t)\n\n paths_to_t_with_u = []\n for path in paths_to_t:\n nodes, sr = path\n new_path = [u] + nodes\n paths_to_t_with_u.append((new_path, sr))\n\n return paths_to_t_with_u"},"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_paths_for_flow(F, s, f):\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links","def get_paths_for_flow(F, s, f):\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links","def paths(p, q):\n if (p, q) == (0, 0):\n return [((0, 0),)]\n answer = list()\n if p > 0:\n west = paths(p - 1, q)\n for path in west:\n answer.append(path + ((p, q),))\n if q > 0:\n south = paths(p, q - 1)\n for path in south:\n answer.append(path + ((p, q),))\n return answer","def get_spliced_paths(self, p_i, p_j):\n p_i_nodes = self.get_path_nodes(p_i)[1:-1]\n p_j_nodes = self.get_path_nodes(p_j)[1:-1]\n # we will splice at least common node\n print(\"Path we are attempting to splice\")\n print(p_i, p_j)\n print(p_i_nodes, p_j_nodes)\n if len(set(p_i_nodes).intersection(set(p_j_nodes))) == 0:\n print(\"no overlap\")\n common_node = min(set(p_i_nodes).intersection(set(p_j_nodes)))\n # find where p_i gets to this node\n index_i = 0\n index_j = 0\n for index, arc in enumerate(p_i):\n destin = self.arc_info[arc][\"destin\"]\n if destin == common_node:\n index_i = index + 1\n break\n for index, arc in enumerate(p_j):\n destin = self.arc_info[arc][\"destin\"]\n if destin == common_node:\n index_j = index + 1\n break\n p_i_prime = p_j[:index_j] + p_i[index_i:]\n p_j_prime = p_i[:index_i] + p_j[index_j:]\n return (p_i_prime, p_j_prime)","def get_path_matrix(self, seed, p):\n neighbors = [] # 8 neighbors of the pixel being processed\n processed = set() # Processed point\n cost = {seed: 0.0} # Accumulated cost, initialized with seed to itself\n paths = {}\n p_x, p_y = p\n s_x, s_y = seed\n min_x = max(0, min(p_x - self.extra_space, s_x - self.extra_space))\n max_x = min(self.x_lim, max(p_x + self.extra_space, s_x + self.extra_space))\n min_y = max(0, min(p_y - self.extra_space, s_y - self.extra_space))\n max_y = min(self.y_lim, max(p_y + self.extra_space, s_y + self.extra_space))\n \n\n self.n_processed = 0\n \n while cost:\n # Expand the minimum cost point\n p = min(cost, key=cost.get)\n neighbors = self._get_neighbors(p, min_x, max_x, min_y, max_y)\n processed.add(p)\n\n # Record accumulated costs and back tracking point for newly expanded points\n for q in [x for x in neighbors if x not in processed]:\n temp_cost = cost[p] + self._weighted_cost(p, q)\n if q in cost:\n if temp_cost < cost[q]:\n cost.pop(q)\n else:\n cost[q] = temp_cost\n processed.add(q)\n paths[q] = p\n \n # Pop traversed points\n cost.pop(p)\n \n self.n_processed += 1\n \n return paths","def dfs_path(graph, s, goals=[]):\n visited = []\n parents = [None]*(len(graph))\n boundary = [s]\n while len(boundary) > 0:\n v = boundary.pop()\n visited += [v]\n for w in neighbours(v, graph):\n if w not in visited and w not in boundary:\n boundary.append(w)\n parents[w] = v\n return get_path(parents, goals[0], goals[1])","def bfs_path(graph, s, goals=[]):\n visited = []\n parents = [None]*len(graph)\n boundary = [s]\n while len(boundary) > 0:\n v = boundary.pop(0)\n visited += [v]\n for w in neighbours(v, graph):\n if w not in visited and w not in boundary:\n boundary.append(w)\n parents[w] = v\n #w's parent\n # put w's parent in the partent list\n return get_path(parents, goals[0], goals[1])","def possible(self):\n return [tuple(path) for path in nx.all_shortest_paths(self._gpm.Graph, source=self.source, target=self.target)]","def get_all_paths(self):\n seen = set()\n for v in self:\n # v in self returns all nodes in the pathgraph\n if v not in seen:\n # self [v] returns a path containing v. If the v does not belong to a path\n # a singleton path [v] is returned\n yield self[v]\n seen.update(self[v])","def DRPathValidation(self, flow, p):\n\t\tpath_rate_lst = []\n\n\t\tarr_time = flow[3]\n\t\tend_time = flow[3] + flow[4]\n\t\tedge_lst = [(p[i], p[i+1]) for i in xrange(len(p)-1)]\n\t\t# Calculate the bottlenecked rate at each event point\n\t\tfor evt in self.event_lst:\n\t\t\tmin_rate = float('inf')\n\t\t\tfor e in edge_lst:\n\t\t\t\tif evt in self.rate_lst[e].keys() and self.rate_lst[e][evt] < min_rate:\n\t\t\t\t\tmin_rate = self.rate_lst[e][evt]\n\t\t\tif min_rate < float('inf'):\n\t\t\t\tpath_rate_lst.append((evt, min_rate))\n\n\t\t# Calculate the cumulative size over the bottleneck rates between arr_time and end_time\n\t\tprev_time = arr_time\n\t\tprev_rate = 0\n\t\tcum_size = 0\n\t\trate_alloc = [(-1, 0)]\t# Start from time -1 with rate 0, so as a benchmark from the beginning\n\t\tfor time, rate in path_rate_lst:\n\t\t\t# Each time period is from prev_time -> min{time, end_time}\n\t\t\tif time > prev_time:\n\t\t\t\tif time < end_time:\n\t\t\t\t\tcum_size += prev_rate * (time - prev_time)\n\t\t\t\t\tcur_ed_time = time\n\t\t\t\telse:\n\t\t\t\t\tcum_size += prev_rate * (end_time - prev_time)\n\t\t\t\t\tcur_ed_time = end_time\n\t\t\t\trate_alloc.append((prev_time, prev_rate))\n\n\t\t\t\tif cum_size >= flow[2]:\n\t\t\t\t\tbreak\n\t\t\t\telif time >= end_time:\n\t\t\t\t\tbreak\n\n\t\t\tprev_time = time\n\t\t\tprev_rate = rate\n\n\t\t# If it can carry the flow size before deadline\n\t\tif cum_size >= flow[2]:\n\t\t\tcum_size -= prev_rate * (cur_ed_time - prev_time)\n\t\t\tnew_end_time = float(flow[2] - cum_size) / prev_rate + prev_time\n\t\t\t# Add the finish rate onto the allocation list\n\t\t\trate_alloc.append((new_end_time, 0))\n\n\t\t\treturn True, edge_lst, self.DRAllocTrim(rate_alloc), new_end_time\n\n\t\t# If not, return the minimum edge regarding the cumulative size\n\t\tedge, size = self.DRFindMinimalEdge(flow, edge_lst)\n\t\treturn False, edge, size","def paths_set(self):\n return self._paths_set","def paths(self, start):\n # This is probably a little slow\n tupadd = lambda p, v: (p[0] + v[0], p[1] + v[1])\n # First, we'll check adjacency moves.\n adj = [tupadd(start, v) for v in DIRECTIONS]\n yield from (p for p in adj if self.board(p) == 0)\n # Now we check repeated hops.\n # We do this by a breadth first search.\n\n #TODO: Consensus on legality of hopping back to start and \"skipping\"\n visited = set(adj)\n to_visit = [start]\n while len(to_visit):\n pt = to_visit.pop(0)\n if pt in visited:\n continue\n\n # We have to actually move a piece\n # But this stops us from considering \"start\" even if we can\n # make some hops and get back to start\n if pt is not start:\n yield pt\n \n visited.add(pt)\n # Compute the hop directions\n dirs = ((tupadd(pt, v), tupadd(pt, tupadd(v, v))) for v in DIRECTIONS)\n to_visit.extend(\n dest for over, dest in dirs\n if self.board(over) > 0\n and self.board(dest) == 0\n and dest not in visited\n and over != start\n )","def get_processed_flow_paths(self) -> Path:\n return self.flow_data_paths.processed_flow_path","def IteratePaths(self):\n self.w = self.setwage(self.K, self.N)\n self.r = self.setrate(self.K, self.N)\n self.b = self.benefit(self.N)\n\n a1, aT = [-1,], []\n\n for q in range(self.Nq):\n if q == 0:\n self.apath[-1] = 0.2\n elif q == 1:\n self.apath[-1] = 0.3\n else:\n self.apath[-1] = max(0,aT[-1]-(aT[-1]-aT[-2])*a1[-1]/(a1[-1]-a1[-2]))\n \n self.npath[-1] = 0\n self.cpath[-1] = self.apath[-1]*(1+self.r) + self.b\n\n for y in range(-2,-(self.T+1),-1): # y = -2, -3,..., -60\n self.apath[y], self.npath[y], self.cpath[y] = self.DirectSolve(y)\n\n aT.append(self.apath[-1])\n a1.append(self.apath[-self.T])\n if (fabs(self.apath[-self.T])<self.tol):\n break\n for y in range(-1,-(self.T+1),-1):\n self.upath[y] = self.util(self.cpath[y],self.npath[y])","def bfs_paths(self, start: str, goal: str) -> List[Path]:\n queue = [(start, [start])]\n while queue:\n (node, path) = queue.pop(0)\n if node not in self.graph:\n yield []\n for _next in set(self.graph[node]) - set(path):\n if _next == goal:\n yield path + [_next]\n elif _next in self.graph:\n queue.append((_next, path + [_next]))","def choose_paths_without_simulation(FT, output_dir, iteration, pathset_paths_df, pathset_links_df, veh_trips_df):\n simulation_iteration = 0\n ######################################################################################################\n FastTripsLogger.info(\" Step 1. Find out board/alight times for all pathset links from vehicle times\")\n\n # could do this just to chosen path links but let's do this to the whole pathset\n pathset_links_df = Assignment.find_passenger_vehicle_times(pathset_links_df, veh_trips_df)\n\n # instead of flag_missed_transfers(), set these to pathfinding results\n pathset_links_df[Assignment.SIM_COL_PAX_ALIGHT_DELAY_MIN] = 0\n pathset_links_df[Assignment.SIM_COL_PAX_A_TIME ] = pathset_links_df[Passenger.PF_COL_PAX_A_TIME]\n pathset_links_df[Assignment.SIM_COL_PAX_B_TIME ] = pathset_links_df[Passenger.PF_COL_PAX_B_TIME]\n pathset_links_df[Assignment.SIM_COL_PAX_LINK_TIME ] = pathset_links_df[Passenger.PF_COL_LINK_TIME]\n pathset_links_df[Assignment.SIM_COL_PAX_WAIT_TIME ] = pathset_links_df[Passenger.PF_COL_WAIT_TIME]\n pathset_links_df[Assignment.SIM_COL_PAX_MISSED_XFER ] = 0\n\n ######################################################################################################\n FastTripsLogger.info(\" Step 2. Calculate costs and probabilities for all pathset paths\")\n (pathset_paths_df, pathset_links_df) = PathSet.calculate_cost(\n iteration, simulation_iteration, Assignment.STOCH_DISPERSION,\n pathset_paths_df, pathset_links_df, FT.passengers.trip_list_df,\n FT.transfers.transfers_df, FT.tazs.walk_df, FT.tazs.drive_df, veh_trips_df, FT.stops)\n\n ######################################################################################################\n FastTripsLogger.info(\" Step 3. Choose a path for each passenger from their pathset\")\n\n # Choose path for each passenger -- pathset_paths_df and pathset_links_df will now have\n # SIM_COL_PAX_CHOSEN >=0 for chosen paths/path links\n (num_passengers_arrived, num_chosen, pathset_paths_df, pathset_links_df) = Passenger.choose_paths(\n True, # choose for everyone\n iteration, simulation_iteration,\n pathset_paths_df, pathset_links_df)\n\n # Write the pathsets\n Passenger.write_paths(output_dir, iteration, simulation_iteration, pathset_paths_df, False, Assignment.OUTPUT_PATHSET_PER_SIM_ITER)\n Passenger.write_paths(output_dir, iteration, simulation_iteration, pathset_links_df, True, Assignment.OUTPUT_PATHSET_PER_SIM_ITER)\n\n # write the final chosen paths for this iteration\n chosen_links_df = Passenger.get_chosen_links(pathset_links_df)\n chosen_links_df[\"iteration\"] = iteration\n Util.write_dataframe(chosen_links_df, \"chosen_links_df\", os.path.join(output_dir, \"chosenpaths_links.csv\"), append=(iteration>1))\n chosen_links_df.drop([\"iteration\"], axis=1, inplace=True)\n\n chosen_paths_df = Passenger.get_chosen_links(pathset_paths_df)\n chosen_paths_df[\"iteration\"] = iteration\n Util.write_dataframe(chosen_paths_df, \"chosen_paths_df\", os.path.join(output_dir, \"chosenpaths_paths.csv\"), append=(iteration>1))\n chosen_paths_df.drop([\"iteration\"], axis=1, inplace=True)\n\n return (num_passengers_arrived, pathset_paths_df, pathset_links_df)","def CostOfPath( self, P, D ):\n cost = 0\n for tup in P:\n cost += D[tup[0]][tup[1]]\n return cost","def all_paths(self, node, destination, dist, path):\n\n d=self.dict()\n p=[]\n for i in range(len(path)):\n p.append(path[i])\n p.insert(len(p),node)\n \n if len(p)-1==dist:\n if node==destination:\n return p\n else:\n return None\n\n my_paths=[]\n\n for a in d[node]:\n if a not in p:\n p1=self.all_paths(a,destination,dist,p)\n\n if p1!=None:\n if isinstance(p1[0],list):\n for i in range(len(p1)):\n my_paths.append(p1[i])\n else:\n my_paths.append(p1)\n\n if len(my_paths)!=0:\n return my_paths\n else:\n return None","def assign_paths(output_dir, FT):\n Assignment.write_configuration(output_dir)\n\n # write the initial load profile, iteration 0\n veh_trips_df = FT.trips.get_full_trips()\n pathset_paths_df = None\n pathset_links_df = None\n\n # write 0-iter vehicle trips\n Assignment.write_vehicle_trips(output_dir, 0, veh_trips_df)\n\n for iteration in range(1,Assignment.ITERATION_FLAG+1):\n FastTripsLogger.info(\"***************************** ITERATION %d **************************************\" % iteration)\n\n if (Assignment.PATHFINDING_TYPE == Assignment.PATHFINDING_TYPE_READ_FILE) and (iteration == 1):\n FastTripsLogger.info(\"Reading paths from file\")\n (new_pathset_paths_df, new_pathset_links_df) = FT.passengers.read_passenger_pathsets(output_dir, include_asgn=False)\n num_paths_found = Assignment.number_of_pathsets(new_pathset_paths_df)\n\n else:\n num_paths_found = Assignment.generate_pathsets(FT, pathset_paths_df, veh_trips_df, output_dir, iteration)\n (new_pathset_paths_df, new_pathset_links_df) = FT.passengers.setup_passenger_pathsets(iteration, FT.stops,\n FT.trips.trip_id_df, FT.trips.trips_df, FT.routes.modes_df,\n FT.transfers, FT.tazs, Assignment.PREPEND_ROUTE_ID_TO_TRIP_ID)\n # write pathfinding results to special PF results file\n Passenger.write_paths(output_dir, 0, 0, new_pathset_paths_df, False, Assignment.OUTPUT_PATHSET_PER_SIM_ITER)\n Passenger.write_paths(output_dir, 0, 0, new_pathset_links_df, True, Assignment.OUTPUT_PATHSET_PER_SIM_ITER)\n\n # write performance info right away in case we crash, quit, etc\n FT.performance.write(output_dir, iteration)\n\n if Assignment.PATHFINDING_EVERYONE:\n pathset_paths_df = new_pathset_paths_df\n pathset_links_df = new_pathset_links_df\n else:\n (pathset_paths_df, pathset_links_df) = Assignment.merge_pathsets(FT.passengers.pathfind_trip_list_df, pathset_paths_df, pathset_links_df, new_pathset_paths_df, new_pathset_links_df)\n num_paths_found = Assignment.number_of_pathsets(pathset_paths_df)\n\n if Assignment.SIMULATION:\n FastTripsLogger.info(\"****************************** SIMULATING *****************************\")\n (num_passengers_arrived, pathset_paths_df, pathset_links_df, veh_trips_df) = \\\n Assignment.simulate(FT, output_dir, iteration, pathset_paths_df, pathset_links_df, veh_trips_df)\n else:\n # if we're not simulating, we can still calculate costs and choose paths\n FastTripsLogger.info(\"****************************** CHOOSING PATHS WITHOUT SIMULATING *****************************\")\n\n (num_passengers_arrived, pathset_paths_df, pathset_links_df) = \\\n Assignment.choose_paths_without_simulation(FT, output_dir, iteration, pathset_paths_df, pathset_links_df, veh_trips_df)\n\n # Set new schedule\n FT.trips.stop_times_df = veh_trips_df\n\n Assignment.write_vehicle_trips(output_dir, iteration, veh_trips_df)\n\n if Assignment.OUTPUT_PASSENGER_TRAJECTORIES:\n PathSet.write_path_times(Passenger.get_chosen_links(pathset_links_df), output_dir)\n\n # capacity gap stuff\n num_bumped_passengers = num_paths_found - num_passengers_arrived\n if num_paths_found > 0:\n capacity_gap = 100.0*num_bumped_passengers/num_paths_found\n else:\n capacity_gap = 100\n\n FastTripsLogger.info(\"\")\n FastTripsLogger.info(\" TOTAL ASSIGNED PASSENGERS: %10d\" % num_paths_found)\n FastTripsLogger.info(\" ARRIVED PASSENGERS: %10d\" % num_passengers_arrived)\n FastTripsLogger.info(\" MISSED PASSENGERS: %10d\" % num_bumped_passengers)\n FastTripsLogger.info(\" CAPACITY GAP: %10.5f\" % capacity_gap)\n\n if False and capacity_gap < 0.001:\n break\n\n # end for loop","def find_path_all_bfs(graph,start,end):\n\tvisited = set()\n\twatched = set()\n\tpaths = []\n\n\twatched.add(start)\n\n\tnodes_queue = [(start,[start])]\n\twhile nodes_queue:\n\t\tcurrent_node, path = nodes_queue.pop(0)\n\n\t\tvisited.add(current_node)\n\n\t\tif (current_node == end):\n\t\t\tpaths.append(path)\n\n\t\tfor adjacent_node in graph[current_node]:\n\t\t\tif (adjacent_node not in watched) and (adjacent_node not in visited):\n\t\t\t\tnodes_queue.append((adjacent_node, path+[adjacent_node]))\n\n\treturn paths","def constructShortestPath(self):\r\n sp = []\r\n v = self.t\r\n while self.preds[v]: # is not None\r\n sp.append(v)\r\n v = self.preds[v]\r\n sp.append(self.s) # source\r\n sp.reverse() # to have the path from source to dest and not t to s\r\n return sp, self.graph.getCoords(sp)","def find_paths(self, source: str, target: str, n_requested_paths: int = 3,\n n_skipped_paths: int = 0) -> List[Tuple[List[str], float]]:\n assert self.graph_handler\n found_paths = []\n for path in self._k_shortest_paths(self.graph_handler.graph, source, target, n_requested_paths,\n weight=\"weight\", path_start=n_skipped_paths):\n path_length = nx.path_weight(self.graph_handler.graph, path, \"weight\")\n found_paths.append((path, path_length))\n\n return found_paths","def allPairsShortestPath(g):\r\n #dist+pred will be dicts (key:vtx, val:dict->KEY:toVtx, VAL:dist/pred) \r\n dist = {}\r\n pred = {}\r\n #for all vertices, create dict values with vertex as key\r\n for u in g: \r\n dist[u] = {} \r\n pred[u] = {}\r\n #for all vertices, set init. dist+pred to all vertices, including self\r\n for v in g: \r\n dist[u][v] = sys.maxsize\r\n pred[u][v] = None\r\n\r\n #finish off init with obvious dist and pred to self as 0 and None\r\n dist[u][u] = 0\r\n pred[u][u] = None\r\n\r\n #for all vertices in graph for current vertex u, set obvious..\r\n #..neighboring direct dist and pred\r\n for v in g[u]:\r\n dist[u][v] = g[u][v]\r\n pred[u][v] = u\r\n\r\n #this is the heavy lifting to figure out...\r\n for mid in g:\r\n for u in g:\r\n for v in g:\r\n newlen = dist[u][mid] + dist[mid][v]\r\n if newlen < dist[u][v]:\r\n dist[u][v] = newlen\r\n pred[u][v] = pred[mid][v]\r\n\r\n return (dist,pred)","def calculate_path(self):\n\n mid_states = []\n\n # Add in between states\n for i in range(Constants.NUMBER_LAPS):\n mid_states = mid_states + Constants.LAP_STATES\n\n # Concatenate beginning, middle and end states to obtain full path of states\n self.path_states = Constants.BEGINNING_STATES + mid_states + Constants.END_STATES\n\n # Determine the amount of times that the smallbot will drive forward during the path\n self.times_driven_forward = self.path_states.count('CREEP_FORWARD')\n\n print(\"Calculated path: \", self.path_states)","def dfs_paths(graph, start, goal, method='dfs'):\n \n # Define the search method\n stack_pop = -1\n if method == 'bfs':\n stack_pop = 0\n \n stack = [(start, [start])]\n while stack:\n (vertex, path) = stack.pop(stack_pop)\n neighbors = node_neighbors(graph, vertex)\n for next_node in set(neighbors) - set(path):\n if next_node == goal:\n yield path + [next_node]\n else:\n stack.append((next_node, path + [next_node]))","def get_potential_pw_splice_pairs(self):\n self.print_out()\n path_pairs = []\n for i, path_1 in enumerate(self.paths):\n for j, path_2 in enumerate(self.paths):\n if j != i:\n p1_nodes = self.get_path_nodes(path_1)[1:-1]\n p2_nodes = self.get_path_nodes(path_2)[1:-1]\n if len(set(p1_nodes).intersection(set(p2_nodes))) != 0:\n path_pairs.append((i,j))\n path_pairs.sort()\n return path_pairs","def find_trip_based_pathset(iteration, pathset, hyperpath, trace):\n # FastTripsLogger.debug(\"C++ extension start\")\n # send it to the C++ extension\n (ret_ints, ret_doubles, path_costs, process_num,\n label_iterations, num_labeled_stops, max_label_process_count,\n ms_labeling, ms_enumerating,\n bytes_workingset, bytes_privateusage) = \\\n _fasttrips.find_pathset(iteration, pathset.person_id_num, pathset.trip_list_id_num, hyperpath,\n pathset.user_class, pathset.purpose, pathset.access_mode, pathset.transit_mode, pathset.egress_mode,\n pathset.o_taz_num, pathset.d_taz_num,\n 1 if pathset.outbound() else 0, float(pathset.pref_time_min),\n 1 if trace else 0)\n # FastTripsLogger.debug(\"C++ extension complete\")\n # FastTripsLogger.debug(\"Finished finding path for person %s trip list id num %d\" % (pathset.person_id, pathset.trip_list_id_num))\n pathdict = {}\n row_num = 0\n\n for path_num in range(path_costs.shape[0]):\n\n pathdict[path_num] = {}\n pathdict[path_num][PathSet.PATH_KEY_COST ] = path_costs[path_num, 0]\n pathdict[path_num][PathSet.PATH_KEY_PROBABILITY] = path_costs[path_num, 1]\n # List of (stop_id, stop_state)\n pathdict[path_num][PathSet.PATH_KEY_STATES ] = []\n\n # print \"path_num %d\" % path_num\n\n # while we have unprocessed rows and the row is still relevant for this path_num\n while (row_num < ret_ints.shape[0]) and (ret_ints[row_num, 0] == path_num):\n # print row_num\n\n mode = ret_ints[row_num,2]\n # todo\n if mode == -100:\n mode = PathSet.STATE_MODE_ACCESS\n elif mode == -101:\n mode = PathSet.STATE_MODE_EGRESS\n elif mode == -102:\n mode = PathSet.STATE_MODE_TRANSFER\n elif mode == -103:\n mode = Passenger.MODE_GENERIC_TRANSIT_NUM\n\n if hyperpath:\n pathdict[path_num][PathSet.PATH_KEY_STATES].append( (ret_ints[row_num, 1], [\n ret_doubles[row_num,0], # label,\n Util.SIMULATION_DAY_START + datetime.timedelta(minutes=ret_doubles[row_num,1]), # departure/arrival time\n mode, # departure/arrival mode\n ret_ints[row_num,3], # trip id\n ret_ints[row_num,4], # successor/predecessor\n ret_ints[row_num,5], # sequence\n ret_ints[row_num,6], # sequence succ/pred\n datetime.timedelta(minutes=ret_doubles[row_num,2]), # link time\n ret_doubles[row_num,3], # cost\n Util.SIMULATION_DAY_START + datetime.timedelta(minutes=ret_doubles[row_num,4]) # arrival/departure time\n ] ) )\n else:\n pathdict[path_num][PathSet.PATH_KEY_STATES].append( (ret_ints[row_num, 1], [\n datetime.timedelta(minutes=ret_doubles[row_num,0]), # label,\n Util.SIMULATION_DAY_START + datetime.timedelta(minutes=ret_doubles[row_num,1]), # departure/arrival time\n mode, # departure/arrival mode\n ret_ints[row_num,3], # trip id\n ret_ints[row_num,4], # successor/predecessor\n ret_ints[row_num,5], # sequence\n ret_ints[row_num,6], # sequence succ/pred\n datetime.timedelta(minutes=ret_doubles[row_num,2]), # link time\n datetime.timedelta(minutes=ret_doubles[row_num,3]), # cost\n Util.SIMULATION_DAY_START + datetime.timedelta(minutes=ret_doubles[row_num,4]) # arrival/departure time\n ] ) )\n row_num += 1\n\n perf_dict = { \\\n Performance.PERFORMANCE_COLUMN_PROCESS_NUM : process_num,\n Performance.PERFORMANCE_COLUMN_LABEL_ITERATIONS : label_iterations,\n Performance.PERFORMANCE_COLUMN_NUM_LABELED_STOPS : num_labeled_stops,\n Performance.PERFORMANCE_COLUMN_MAX_STOP_PROCESS_COUNT: max_label_process_count,\n Performance.PERFORMANCE_COLUMN_TIME_LABELING_MS : ms_labeling,\n Performance.PERFORMANCE_COLUMN_TIME_ENUMERATING_MS : ms_enumerating,\n Performance.PERFORMANCE_COLUMN_TRACED : trace,\n Performance.PERFORMANCE_COLUMN_WORKING_SET_BYTES : bytes_workingset,\n Performance.PERFORMANCE_COLUMN_PRIVATE_USAGE_BYTES : bytes_privateusage\n }\n return (pathdict, perf_dict)","def paths(self):\n return self._visit(self.start)","def get_special_paths(set_path: str, set_value, sp_to_label: Dict, label_to_ship: Dict):\n additions = set()\n if type(set_value) is not dict:\n # If this path is already labelled as special, then check that the ship matched with it does fit\n if set_path in sp_to_label:\n if label_to_ship[sp_to_label[set_path]].check_fit(set_value):\n return additions\n\n # If this is something a ship covers, add it as a special path\n for ship in label_to_ship.values():\n if ship.check_fit(set_value):\n additions.add( (set_path, ship.get_label()) )\n\n # If this is a dict, recursively build the set of additional paths\n else:\n for k, v in set_value.items():\n assert check_valid_key_name(k), \"Invalid Key: {}\".format(k)\n if set_path != Path.rootPath():\n child_path = \"{}.{}\".format(set_path, k)\n else:\n child_path = \".{}\".format(k)\n child_add = get_special_paths(child_path, v, sp_to_label, label_to_ship)\n additions = additions.union(child_add)\n\n return additions","def path(l_s, l_f, leg_list):\n # candidates =\n return min(heuristic_path([l_s], l_f, leg_list, []), key = len)","def dfs_paths_dict_recur(\n graph: Mapping[Node, set[Node]],\n start: Node,\n goal: Node,\n path: Optional[list[Node]] = None\n) -> Iterable[list[Node]]:\n if path is None:\n path = [start]\n if start == goal:\n yield path\n else:\n for next_node in graph[start].difference(path):\n next_path = path + [next_node]\n yield from dfs_paths_dict_recur(graph, next_node, goal, next_path)","def calc_critical_paths(self):\n visited = set([])\n nodes = set(self.get_leaves())\n\n while nodes:\n n = nodes.pop()\n n.update_critical_path(n.latency())\n visited.add(n)\n cp = n.critical_path\n\n for p in n.parents:\n p.update_critical_path(cp + p.latency())\n # if p not in visited:\n nodes.add(p)\n # visited.add(p)\n\n for d in n.serial_parents:\n d.update_critical_path(cp + 1)\n # if d not in visited:\n nodes.add(d)\n # visited.add(d)","def split_path(self, path):\n# import pdb;pdb.set_trace()\n if len(path) < 2:\n return [path]\n\n paths = [[path[0]]]\n for i in range(1, len(path)-1):\n p0 = path[i-1]\n p1 = path[i]\n p2 = path[i+1]\n v1 = p0 - p1\n v2 = p2 - p1\n d = np.sum(v1 * v2)\n if d > 0:\n print('found cusp')\n paths.append([])\n paths[-1].append(p1)\n paths[-1].append(path[-1])\n paths = [np.stack(p, axis=0) for p in paths] \n return paths","def collect_paths(rllab_env: Env,\n prob_meta: ProblemMeta,\n get_action: Any,\n n_paths: int,\n max_len: int) -> Tuple[List[Path], float]:\n assert max_len > 0\n\n paths = []\n uenv = unwrap_env(rllab_env)\n ospace = uenv.observation_space\n tot_rew = 0.0\n\n for path_num in range(n_paths):\n path = []\n obs = rllab_env.reset()\n done = False\n\n for step_num in range(max_len):\n # TODO: some fraction of the time I should take a random action,\n # and some fraction of the time I should take an LRTDP-recommended\n # action. Maybe---need to think about the optimal thing to do here.\n action, _ = get_action(obs)\n path.append((ospace.unflatten(obs),\n prob_meta.bound_acts_ordered[action]))\n # done is true in both goal states and recognised dead ends\n # info contains 'goal_reached' and 'progress', which can both be\n # useful\n obs, rew, done, info = rllab_env.step(action)\n tot_rew += rew\n if done:\n break\n else:\n # Need to do this outside loop for last step so that we can get\n # both beginning and end. Maybe it's better just to ignore last\n # step?\n path.append((ospace.unflatten(obs),\n prob_meta.bound_acts_ordered[action]))\n paths.append(path)\n\n npaths = len(paths)\n succ_rate = tot_rew / npaths\n\n return paths, succ_rate","def Sidetrack2Path(tree, sidetracks, s, t):\n\tvisited = set()\t\t# visited nodes\n\tpath = []\t\t# set of edges\n\tsidenodes = set(links[e][0] for e in sidetracks)\t# nodes that needs to be sidetracked\n\tcurrent = s\n\twhile current != t:\n\t\t# Loop detection\n\t\tif current in visited:\n\t\t\treturn []\n\t\telse:\n\t\t\tvisited.add(current)\n\t\t# No loop is found yet, proceed one hop\n\t\tif current in sidenodes:\n\t\t\tedge = [e for e in sidetracks if links[e][0] == current]\n\t\t\tcurrent = links[edge[0]][1]\n\t\t\tpath.append(edge[0])\n\t\telse:\n\t\t\tedge = [i for i,e in enumerate(links) if e == (current,tree[current])]\n\t\t\tcurrent = links[edge[0]][1]\n\t\t\tpath.append(edge[0])\n\t# Destination reached. Return the path\n\treturn path","def find_all_path(self, start_vertex, end_vertex, path=[]):\n\n graph = self.__graph_dict\n path = path + [start_vertex]\n if start_vertex == end_vertex:\n return [path]\n\n if start_vertex not in graph:\n return []\n\n paths = []\n for vertex in graph[start_vertex]:\n if vertex not in path:\n extended_paths = self.find_all_path(vertex, end_vertex,path)\n for p in extended_paths:\n paths.append(p)\n return paths","def find_unique_paths(self, source: str, target: str, number: int = 3) -> List[Tuple[List[str], float]]:\n assert self.graph_handler\n counter = 0\n path_tuple_list = list()\n # # # Initialise iterator over shortest simple paths if it is either not set or source/target do not match\n if not self._use_old_iterator or \\\n self._unique_iterator_memory is None or \\\n self._unique_iterator_memory[0][0][0] != source or \\\n self._unique_iterator_memory[0][0][-1] != target:\n path_iterator = iter(nx.shortest_simple_paths(self.graph_handler.graph, source, target, weight=\"weight\"))\n # # # Find first path and its cost\n old_path = next(path_iterator)\n old_path_cost = nx.path_weight(self.graph_handler.graph, old_path, weight=\"weight\")\n else:\n path_iterator = self._unique_iterator_memory[1]\n old_path = self._unique_iterator_memory[0][0]\n old_path_cost = self._unique_iterator_memory[0][1]\n\n while counter < number:\n same_cost = True\n tmp_path_list: List[List[str]] = list()\n # # # Collect all paths with same cost\n # TODO: Parameter for max tmp paths\n n_max_collected_paths = 10\n while same_cost and len(tmp_path_list) < n_max_collected_paths:\n # # # Append old path to tmp_path list\n tmp_path_list.append(old_path)\n # # # Get next path and its cost\n new_path = next(path_iterator, None)\n # # # Break loop if no path is returned\n if new_path is None:\n break\n new_path_cost = nx.path_weight(self.graph_handler.graph, new_path, weight=\"weight\")\n # # # Check if new cost different to old cost\n if abs(old_path_cost - new_path_cost) > 1e-12:\n same_cost = False\n # # # Overwrite old path with new path\n old_path = new_path\n\n # # # Append path with most nodes to tuple list and its cost\n path_tuple_list.append((max(tmp_path_list, key=lambda x: len(x)), # pylint: disable=unnecessary-lambda\n old_path_cost))\n # # # Break counter loop if no more paths to target are found\n if new_path is None:\n break\n old_path_cost = new_path_cost\n counter += 1\n # # # Store iterator and path info (list of nodes and length)\n if new_path is not None:\n self._unique_iterator_memory = ((new_path, new_path_cost), path_iterator)\n return path_tuple_list","def cycles(p: List[int]) -> List[Set[int]]:\n validate_permutation(p)\n\n todo = list(range(len(p)))\n cycles = []\n\n while todo:\n start = todo.pop(0)\n\n cycle = (start,)\n position = p[start]\n\n while position != start:\n todo.remove(position)\n cycle += (position, )\n position = p[position]\n\n cycles.append(cycle)\n\n return cycles","def get_easy_possible_paths(mario_position: tuple, princess_position: tuple) -> Set[tuple]:\n # getting 'distance' between Mario and princess in coordinates\n distance = np.subtract(princess_position, mario_position)\n\n # create required moves from distance\n moves_list = []\n for i in range(abs(distance[0])):\n moves_list.append((1, 0) if distance[0] >= 0 else (-1, 0))\n for i in range(abs(distance[1])):\n moves_list.append((0, 1) if distance[1] >= 0 else (0, -1))\n\n # create possible paths from possible moves, using set to remove duplicates\n all_paths_list = set(itertools.permutations(moves_list))\n return all_paths_list","def solution_path(self) -> list[State]:","def scan_P__(P__):\n\n for _P_, P_ in pairwise(P__): # Iterate through pairs of lines.\n _iter_P_, iter_P_ = iter(_P_), iter(P_) # Convert to iterators.\n try:\n _P, P = next(_iter_P_), next(iter_P_) # First pair to check.\n except StopIteration: # No more up_fork-down_fork pair.\n continue # To next pair of _P_, P_.\n while True:\n isleft, olp = comp_edge(_P, P) # Check for 4 different cases.\n if olp and _P['sign'] == P['sign']:\n _P['down_fork_'].append(P)\n P['up_fork_'].append(_P)\n try: # Check for stopping:\n _P, P = (next(_iter_P_), P) if isleft else (_P, next(iter_P_))\n except StopIteration: # No more up_fork - down_fork pair.\n break # To next pair of _P_, P_.\n\n return [*flatten(P__)] # Flatten P__ before return.","def find_all_path(self, start, end, path=[]):\n path = path+[start]\n if start == end:\n return path\n paths = []\n for node in self.graph[start]:\n if node not in path:\n newpaths = self.find_path(node, end, path)\n paths.append(newpaths)\n return paths","def all_DU_paths(CG, T):\n path_to_visit = []\n path_not_visited = []\n for var in CG.var:\n vert_var_in_defv=set()\n vert_var_in_refv=set()\n for vert in CG.vertices:\n if var in vert.defv:\n vert_var_in_defv.add(vert.label)\n elif var in vert.refv:\n vert_var_in_refv.add(vert.label)\n couples = product(vert_var_in_defv, vert_var_in_refv)\n for vert_def, vert_ref in couples:\n #paths_remaining = list(CG.simple_partial_paths[(vert_def, vert_ref)])\n path_to_visit += list(CG.simple_partial_paths[(vert_def, vert_ref)])\n path_not_visited += list(CG.simple_partial_paths[(vert_def, vert_ref)])\n for t in T:\n path, variables = apply_path(CG, t)\n vert_found = False\n for label in path:\n cur_vertice=find_vertice_with_label(CG,label)\n if vert_def == label:\n vert_found = True\n\n elif vert_ref == label and vert_found:\n if path in path_not_visited:\n path_not_visited.remove(path)\n break\n\n elif vert_ref != label and var in cur_vertice.refv:\n break\n #print('Test failed')\n #print(paths_remaining, var,vert_def, vert_ref, path)\n #return False\n\n #if paths_remaining:\n # print('Test failed')\n # print(paths_remaining, var, vert_def, vert_ref, path)\n # return False\n\n Graph.coverage_criteria2(path_to_visit, \"not_visited\", path_not_visited)\n if path_not_visited:\n print('Test failed')\n \n else:\n print('Test passed')\n return True","def calculate_paths(topology):\n nodes = topology['nodes']\n edges = topology['links']\n\n dist = [[len(nodes) + 1 for x in range(len(nodes))] for y in range(len(nodes))]\n paths = [[[] for x in range(len(nodes))] for y in range(len(nodes))]\n\n for e in edges.values():\n s, d = int(e['source']), int(e['target'])\n dist[s][d] = dist[d][s] = 1\n paths[s][d] = [e['id']]\n paths[d][s] = [e['id']]\n\n for k in range(len(nodes)):\n for i in range(len(nodes)):\n for j in range(len(nodes)):\n if dist[i][k] + dist[k][j] < dist[i][j]:\n dist[i][j] = dist[i][k] + dist[k][j]\n paths[i][j] = paths[i][k] + paths[k][j]\n return paths","def getPaths(self):\n return self.pathTuple","def shortest_path(start, end):\n\n\tmoves = rubik.quarter_twists\n\n\t# Parent nodes: (Parent_State, move)\n\tstartParents = {}\n\tstartParents[start] = None # Start state has no parent\n\n\t# Parent nodes: (Parent_State, move)\n\tendParents = {}\n\tendParents[end] = None # End state has no parent\n\n\tstartFrontier = [] # Current frontier in start BFS\n\tendFrontier = [] # Current frontier in end BFS\n\n\tstartFrontier.append(start) # Add start state as first and only node to generate next frontier\n\tendFrontier.append(end) # Add end state as first and only node to generate next frontier\n\n\tif end in startParents:\n\t\treturn [] # Start == End : No moves required\n\n\t# We only have to search at most 14 levels in BFS\n\t# Two-way BFS therefore requires 7 concurrent levels from both states\n\tfor i in range(7):\n\n\t\tstartNextFrontier = [] # New empty set for new frontier to be discovered\n\t\tfor state in startFrontier: # Iterate through each rubiks state in this frontier\n\t\t\tfor move in moves: # Apply each move to this state\n\t\t\t\tnextState = rubik.perm_apply(move, state)\n\n\t\t\t\t# Makes sure this new state is not already in the Graph\n\t\t\t\t# This skips nodes that were already permuted in another path,\n\t\t\t\t# essentially trimming the Graph's leaves\n\t\t\t\tif nextState not in startParents:\n\t\t\t\t\tstartParents[nextState] = (state, move) # Store this state's parent + move\n\t\t\t\t\tstartNextFrontier.append(nextState) # Create a node in the next frontier\n\t\t\t\t\n\t\t\t\t# Intersect of both Graphs, Intermediate state of path found\n\t\t\t\tif nextState in endParents:\n\t\t\t\t\treturn solution(startParents, endParents, nextState)\n\n\t\tstartFrontier = startNextFrontier # Make the next frontier the current one\n\n\t\tendNextFrontier = [] # New empty set for new frontier to be discovered\n\t\tfor state in endFrontier: # Iterate through each rubiks state in this frontier\n\t\t\tfor move in moves: # Apply each move to this state\n\t\t\t\tnextState = rubik.perm_apply(move, state)\n\n\t\t\t\t# Makes sure this new state is not already in the Graph\n\t\t\t\t# This skips nodes that were already permuted in another path,\n\t\t\t\t# essentially trimming the Graph's leaves\n\t\t\t\tif nextState not in endParents:\n\t\t\t\t\tendParents[nextState] = (state, move) # Store this state's parent + move\n\t\t\t\t\tendNextFrontier.append(nextState) # Create a node in the next frontier\n\t\t\t\t\n\t\t\t\t# Intersect of both Graphs, Intermediate state of path found\n\t\t\t\tif nextState in startParents:\n\t\t\t\t\treturn solution(startParents, endParents, nextState)\n\n\t\tendFrontier = endNextFrontier # Make the next frontier the current one\n\n\treturn None","def FindAllPaths(graph, start, end, path=[]):\n path = path + [start]\n if start == end:\n return [path]\n if start not in graph:\n return None\n paths = []\n for node in graph[start]:\n if node not in path:\n newpaths = find_all_paths(graph, node, end, path)\n for newpath in newpaths:\n paths.append(newpath)\n return paths","def get_overlapping_path_pairs(self):\n path_pairs = []\n for i, path_1 in enumerate(self.paths):\n for j, path_2 in enumerate(self.paths):\n if j != i:\n if len(set(path_1).intersection(set(path_2))) != 0:\n path_pairs.append((i,j))\n path_pairs.sort()\n return path_pairs","def a_star_ng(graph, heuristic, start, goal):\n path = []\n queue = PriorityQueue()\n queue.put((0, start))\n visited = set(start)\n\n branch = {}\n found = False\n while not queue.empty():\n item = queue.get()\n current_cost = item[0]\n current_node = item[1]\n\n if current_node == goal:\n print('Found a path.')\n found = True\n break\n else:\n for next_node in graph[current_node]:\n cost = graph.edges[current_node, next_node]['weight']\n new_cost = current_cost + cost + heuristic(next_node, goal)\n\n if next_node not in visited:\n visited.add(next_node)\n queue.put((new_cost, next_node))\n\n branch[next_node] = (new_cost, current_node)\n\n path = []\n path_cost = 0\n if found:\n # retrace steps\n path = []\n n = goal\n path_cost = branch[n][0]\n path.append(goal)\n while branch[n][1] != start:\n path.append(branch[n][1])\n n = branch[n][1]\n path.append(branch[n][1])\n # Wanted the sets to have ints, but had floats, so casted them to int\n path = [(int(p[0]), int(p[1])) for p in path]\n return path[::-1], path_cost","def find_all_paths(graph, current, destination, path=[]):\n\n path = path + [current]\n\n if current == destination:\n return path\n\n # difference: instead of returning none, return an empty path\n if current not in graph:\n reutrn []\n\n # create a list for storing the results (because there will be > 1)\n paths = []\n\n for node in graph[current]:\n if node not in path:\n # the change is to return a list of path lists, instead of one path\n newpaths = find_all_paths(graph, node, destination, path)\n # now, for each path returned, add it to the solutions list\n for newpath in newpaths:\n paths.append(newpath)\n return paths","def _points_to_paths(self, points):\n prev = points[0]\n result = []\n for point in points[1:]:\n path = specctraobj.Path()\n path.aperture_width = self._from_pixels(1)\n path.vertex.append(prev)\n path.vertex.append(point)\n result.append(path)\n prev = point\n return result","def summarize_paths(trips):\n\t# get a set of distinct Path objects. We have to use equality rather than \n\t# hashing here. \n\titins = []\n\t# add all OTP paths to the Itinerary each belongs to, creating new ones\n\t# along the way \n\tfor trip in trips:\n\t\tif trip.path not in itins:\n\t\t\titins.append( Itinerary(trip.path) )\n\t\ti = itins.index(trip.path)\n\t\titins[i].add_OTP_trip( trip )\n\t# remove any itineraries which have no travel times in the DB at all \n\tbad_itins = []\n\tfor i, itin in enumerate(itins):\n\t\ttts = [ d for d in itin.departures if d.travel_time ]\n\t\tif len(tts) == 0: bad_itins.append(i)\n\tfor i in reversed(bad_itins):\n\t\titins.pop(i)\n\treturn itins","def makePath(P, path, src, dst):\n print(\"Path from \"+src+\" to \"+dst)\n previousV = P[dst]\n while previousV != src:\n path.push(previousV)\n temp = previousV\n previousV = P[temp]\n path.push(previousV)\n for i in range(path.getCount()):\n print(path.pop())","def find_all_paths(graph, start, end, path=[]):\n path = path + [start]\n if start == end:\n return [path]\n paths = []\n for node in graph[start]:\n newpaths = find_all_paths(graph, node, end, path)\n paths += newpaths\n return paths","def shortest_path_search(start, successors, is_goal):\n if is_goal(start):\n return [start]\n explored = set()\n frontier = [ [start] ] \n while frontier:\n path = frontier.pop(0)\n s = path[-1]\n for (state, action) in successors(s).items():\n if state not in explored:\n explored.add(state)\n path2 = path + [action, state]\n if is_goal(state):\n return path2\n else:\n frontier.append(path2)\n return Fail","def getPaths(self):\n\n trafficEndPoints = []\n # A job denotes a traffic flow, which corresponds to an iperf task.\n for job in self.config.trace.jobs:\n trafficEndPoints.append((job['src'], job['dst']))\n\n # Obtain details about user-specified non-default links.\n configuredLinks = []\n for linkInfo in self.config.topoData['linkInfos']:\n configuredLinks.append((linkInfo['src'], linkInfo['dst']))\n\n paths = None\n spec = self.config.topoData['flowSpec']\n if spec == 'shortest_path':\n # export paths info and create routing conf using shortest paths\n adjFile = self.config.adjacencyFile\n writeAdjList(self.net, adjFile)\n info(\"**** [G2]: adjacency list written to file\", adjFile, \"\\n\")\n\n outfile = os.path.join(self.config.outPath, SHORTEST_PATH_FILE)\n paths = generateShortestPaths(adjFile, outfile, trafficEndPoints, configuredLinks)\n info(\"**** [G2]: shortest paths written to file\", outfile, \"\\n\")\n # Note: Since there can be multiple shortest paths between two endpoints, solution could vary.\n elif \".json\" in spec:\n info(\"**** [G2]: reading path info from\", spec, \"\\n\")\n paths = readFromPathFile(spec)\n else:\n paths = None\n return paths","def select_paths(self, dpaths=None):\r\n \r\n locs = [] # Find list of starting locs\r\n if len(dpaths) == 0:\r\n return [], []\r\n \r\n for dpath in dpaths:\r\n locs.append(dpath.path[0]) # Get starting loc\r\n \r\n start_locs = self.get_starts(locs=locs)\r\n start_paths = [] # Get paths with these starting locs\r\n other_paths = []\r\n for dpath in dpaths:\r\n if dpath.path[0] in start_locs:\r\n start_paths.append(dpath)\r\n else:\r\n other_paths.append(dpath)\r\n last = self.get_val(\"last\")\r\n if last is 0 or last == \"\":\r\n last = len(dpaths)\r\n closed_tour = self.get_val(\"closed_tour\")\r\n not_tour = self.get_val(\"not_tour\")\r\n comp = self.get_val(\"comp\") \r\n not_comp = self.get_val(\"not_comp\") \r\n\r\n arr_list = start_paths\r\n other_list = other_paths\r\n if closed_tour or not_tour:\r\n a_list = []\r\n o_list = []\r\n for ad in arr_list:\r\n used = False\r\n is_tour = ad.is_closed_tour\r\n if closed_tour:\r\n if is_tour:\r\n a_list.append(ad)\r\n used = True\r\n if not_tour:\r\n if not is_tour:\r\n a_list.append(ad)\r\n used = True\r\n if not used:\r\n o_list.append(ad)\r\n arr_list = a_list\r\n other_list += o_list \r\n \r\n if comp or not_comp:\r\n a_list = []\r\n o_list = []\r\n for ad in arr_list:\r\n used = False\r\n is_comp = ad.is_complete_tour\r\n if comp:\r\n if is_comp:\r\n a_list.append(ad)\r\n used = True\r\n if not_comp:\r\n if not is_comp:\r\n a_list.append(ad)\r\n used = True\r\n if not used:\r\n o_list.append(ad)\r\n arr_list = a_list\r\n other_list += o_list\r\n self.prev_arr_list = arr_list \r\n return arr_list, other_list","def shortest_path_search(start, successors, is_goal):\n if is_goal(start): return [start]\n explored = set()\n frontier = [[start]]\n while frontier:\n path = frontier.pop(0)\n s = path[-1]\n for (state,action) in successors(s).items():\n if state not in explored:\n explored.add(state)\n npath = path + [action,state]\n if is_goal(state): return npath\n else: frontier.append(npath)\n return []","def sample_endpoint_conditioned_path(\n initial_state, final_state, path_length, P):\n # get the size of the state space and do some input validation\n MatrixUtil.assert_transition_matrix(P)\n nstates = len(P)\n if not (0 <= initial_state < nstates):\n raise ValueError('invalid initial state')\n if not (0 <= final_state < nstates):\n raise ValueError('invalid final state')\n # take care of edge cases\n if path_length == 0:\n return []\n elif path_length == 1:\n if initial_state != final_state:\n raise ValueError('unequal states for a path of length one')\n return [initial_state]\n elif path_length == 2:\n return [initial_state, final_state]\n # sample the path\n path = [initial_state]\n for i in range(path_length-2):\n remaining_power = path_length - 2 - i\n M = linalg.matrix_power(P, remaining_power)\n previous_state = path[i]\n weight_state_pairs = []\n for state_index in range(nstates):\n weight = 1\n weight *= P[previous_state, state_index]\n weight *= M[state_index, final_state]\n weight_state_pairs.append((weight, state_index))\n next_state = Util.weighted_choice(weight_state_pairs)\n path.append(next_state)\n path.append(final_state)\n return path","def _find_all_paths(self, start_vertex: str, end_vertex: str, path=[]):\n path = path + [start_vertex]\n if start_vertex == end_vertex:\n return [path]\n\n paths = []\n for vertex in self.graph[start_vertex]:\n if vertex not in path:\n extended_paths = self._find_all_paths(vertex,\n end_vertex,\n path)\n for p in extended_paths:\n paths.append(p)\n return paths","def get_k_shortest_paths(env: RailEnv,\n source_position: Tuple[int, int],\n source_direction: int,\n target_position=Tuple[int, int],\n k: int = 1, debug=False) -> List[Tuple[Waypoint]]:\n\n # P: set of shortest paths from s to t\n # P =empty,\n shortest_paths: List[Tuple[Waypoint]] = []\n\n # countu: number of shortest paths found to node u\n # countu = 0, for all u in V\n count = {(r, c, d): 0 for r in range(env.height) for c in range(env.width) for d in range(4)}\n\n # B is a heap data structure containing paths\n # N.B. use OrderedSet to make result deterministic!\n heap: OrderedSet[Tuple[Waypoint]] = OrderedSet()\n\n # insert path Ps = {s} into B with cost 0\n heap.add((Waypoint(source_position, source_direction),))\n\n # while B is not empty and countt < K:\n while len(heap) > 0 and len(shortest_paths) < k:\n if debug:\n print(\"iteration heap={}, shortest_paths={}\".format(heap, shortest_paths))\n # – let Pu be the shortest cost path in B with cost C\n cost = np.inf\n pu = None\n for path in heap:\n if len(path) < cost:\n pu = path\n cost = len(path)\n u: Waypoint = pu[-1]\n if debug:\n print(\" looking at pu={}\".format(pu))\n\n # – B = B − {Pu }\n heap.remove(pu)\n # – countu = countu + 1\n\n urcd = (*u.position, u.direction)\n count[urcd] += 1\n\n # – if u = t then P = P U {Pu}\n if u.position == target_position:\n if debug:\n print(\" found of length {} {}\".format(len(pu), pu))\n shortest_paths.append(pu)\n\n # – if countu ≤ K then\n # CAVEAT: do not allow for loopy paths\n elif count[urcd] <= k:\n possible_transitions = env.rail.get_transitions(*urcd)\n if debug:\n print(\" looking at neighbors of u={}, transitions are {}\".format(u, possible_transitions))\n # for each vertex v adjacent to u:\n for new_direction in range(4):\n if debug:\n print(\" looking at new_direction={}\".format(new_direction))\n if possible_transitions[new_direction]:\n new_position = get_new_position(u.position, new_direction)\n if debug:\n print(\" looking at neighbor v={}\".format((*new_position, new_direction)))\n\n v = Waypoint(position=new_position, direction=new_direction)\n # CAVEAT: do not allow for loopy paths\n if v in pu:\n continue\n\n # – let Pv be a new path with cost C + w(u, v) formed by concatenating edge (u, v) to path Pu\n pv = pu + (v,)\n # – insert Pv into B\n heap.add(pv)\n\n # return P\n return shortest_paths","def generate_paths(self, paths: list) -> list or int:\n path_count = 0\n new_paths = {}\n # follow each path in the paths list\n for path in paths:\n # find neighbours from last position in each path\n neighbours = self.neighbours(path[-1])\n for neighbour in neighbours:\n if neighbour in self.queue.values():\n continue # if neighbour in queue, go to next neighbour\n # find grid value of neighbour\n grid_value = self.grid[neighbour[1]][neighbour[0]]\n if grid_value == 1:\n new_paths[path_count] = path.copy()\n new_paths[path_count].append(neighbour) # add path to dict\n self.queue[path_count + 1] = neighbour # add neighbour to queue\n path_count += 1 # increase count of number of paths\n if grid_value == 9:\n return len(path)\n\n # roll dict out into list of paths\n paths_store = [new_paths[key] for key in new_paths]\n\n return paths_store","def expand_paths_by_nodes(self, paths):\n paths_formatted = set()\n # Expand each path\n for path in paths:\n if len(path) < 2:\n continue\n expanded_paths = set()\n if self.include_entity:\n relations_for_each_step = [[path[0]]]\n else:\n relations_for_each_step = []\n for index in range(1, len(path)):\n node1 = path[index-1]\n node2 = path[index]\n if (node1, node2) in self.pair_to_relations:\n relations = self.pair_to_relations[(node1, node2)]\n else:\n print(node1, node2)\n relations_for_each_step.append(relations)\n if self.include_entity:\n relations_for_each_step.append([node2])\n expanded_paths.update(list(itertools.product(*relations_for_each_step)))\n paths_formatted.update(expanded_paths)\n return paths_formatted","def get_TSP(graph):\n # row - from, column - to\n partial_cost = {}\n prev_vertices = {}\n n = len(graph)\n vertices = frozenset(range(1, n))\n for i in range(1, n):\n partial_cost[(i, frozenset())] = graph[0][i]\n prev_vertices[(i, frozenset())] = 0\n for i in range(1, n - 1):\n for s in frozenset(combinations(vertices, i)):\n s = frozenset(s)\n for j in vertices - s:\n partial_cost[j, frozenset(s)], prev_vertices[j, frozenset(s)] = get_min_cost_and_opt_prev(graph, partial_cost, j, s)\n partial_cost[0, vertices], prev_vertices[0, vertices] = get_min_cost_and_opt_prev(graph, partial_cost, 0, vertices)\n path = get_path(prev_vertices, vertices)\n return path, partial_cost[0, vertices]","def find_paths(self, source, destination, closed=None):\n if closed is None:\n closed = set()\n closed.add(source)\n links = {x.trusted for x in self._tau\n if x.truster == source and x.trusted not in closed}\n if len(links) == 0: # base\n return []\n if destination in links: # base\n return [[Trust(source, destination)]]\n # recurse\n retval = []\n for link in links:\n linkpaths = self.find_paths(link, destination, closed)\n for path in linkpaths:\n path.insert(0, Trust(source, link))\n retval += linkpaths\n\n for path in retval:\n if None in path:\n retval.remove(path)\n if len(retval) == 0:\n return []\n return retval","def path(self): # Path taken to reach Goal\n node, path_back = self, []\n while node:\n path_back.append(node)\n node = node.parent\n return list(reversed(path_back))","def shortest_path(start, end):\n if start == end:\n return []\n \n start_frontier = Queue.Queue()\n start_parent = {}\n start_level = {}\n start_parent_move = {}\n start_frontier.put(start)\n start_level[start] = 0\n start_parent[start] = None\n start_parent_move[start] = None\n \n end_frontier = Queue.Queue()\n end_parent = {}\n end_level = {}\n end_parent_move = {}\n end_frontier.put(end)\n end_level[end] = 0\n end_parent[end] = None\n end_parent_move[end] = None\n \n intersectFound = False\n intersect = None\n level = 0\n while (True):\n level += 1\n# print (\"level = \" + str(level))\n if not start_frontier.empty():\n vertex = start_frontier.get()\n for move in rubik.quarter_twists:\n position = rubik.perm_apply(move,vertex)\n if position not in start_parent:\n# print (\"start permutation unvisited\")\n start_parent[position] = vertex\n start_level[position] = level\n start_parent_move[position] = move\n start_frontier.put(position)\n if position in end_parent:\n# print (\"position exists in end_parent\")\n intersect = position\n intersectFound = True\n break\n if intersectFound:\n break\n if not end_frontier.empty():\n vertex = end_frontier.get()\n for move in rubik.quarter_twists:\n position = rubik.perm_apply(move,vertex)\n if position not in end_parent:\n# print (\"end permutation unvisited\")\n end_parent[position] = vertex\n end_level[position] = level\n end_parent_move[position] = move\n end_frontier.put(position)\n if position in start_parent:\n# print (\"position exists in start_parent\")\n intersect = position\n intersectFound = True\n break\n if intersectFound:\n break\n if end_frontier.empty() and start_frontier.empty():\n break\n \n if intersect is None:\n return None\n \n path = []\n pos = intersect\n while (start_parent[pos] is not None):\n path.insert(0,start_parent_move[pos])\n pos = start_parent[pos]\n \n pos = intersect\n while (end_parent[pos] is not None):\n move = rubik.perm_inverse(end_parent_move[pos])\n path.append(move)\n pos = end_parent[pos]\n \n# path = [None] * start_level[intersect]\n# pos = intersect\n# move = start_parent_move[pos]\n# path[start_level[intersect]-1] = move\n# for i in range(start_level[intersect]-2,-1,-1):\n# if (start_parent[pos] is not None):\n# pos = start_parent[pos]\n# move = start_parent_move[pos]\n# path[i] = move\n# \n# pos = intersect\n# while (end_parent[pos] is not None):\n# move = rubik.perm_inverse(end_parent_move[pos])\n# path.append(move)\n# pos = end_parent[pos]\n \n return path","def calculate_paths(shape: Tuple[int, int], point: Tuple[int, int]) -> int:\n\tn, m = map(int, input().split())\n\tf = [[0] * (m+1) for i in range(n+1)]\n\tf[1][1] = 1\n\tfor i in range(2, n+1):\n\t\tfor j in range(2, m + 1):\n\t\t\tf[i][j] = f[i-2][j-2] + f[i-2][j-1]\n\treturn n + m","def shortest_path_search(start, successors, is_goal):\r\n if is_goal(start):\r\n return [start]\r\n explored = set()\r\n frontier = [ [start] ]\r\n while frontier:\r\n path = frontier.pop(0)\r\n s = path[-1]\r\n for (state, action) in successors(s).items():\r\n if state not in explored:\r\n explored.add(state)\r\n path2 = path + [action, state]\r\n if is_goal(state):\r\n return path2\r\n else:\r\n frontier.append(path2)\r\n return Fail","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 stairway_path(stairway: Sequence[Union[float, int]]) -> Union[float, int]:\n # определяем начальный список стоимости перехода по ступенькам\n sum_cost = [0 for _ in range(len(stairway))]\n sum_cost[0] = stairway[0] # стоимость шага на 1 ступеньку\n sum_cost[1] = stairway[1] # стоимость шага на 2 ступеньку\n\n for i in range(2, len(stairway)): # цикл начиная со 2 ступеньки и до конца лестницы\n # соимость перехода = стоимость на i-ой ступ. + минимум стоимости(переход с i-2, переход с i-1)\n sum_cost[i] = stairway[i] + min(sum_cost[i-2], sum_cost[i-1])\n\n return sum_cost[-1] # возвращаем последний результат в списке","def _compute_ptdfs(self):\n z = self._compute_z()\n s = np.zeros([self.n_nodes, self.n_nodes, self.n_nodes])\n for k in range(self.n_nodes):\n for L in range(self.n_nodes):\n for i in range(self.n_nodes):\n if k == 0 and L != 0:\n s[k, L, i] = -1 * z[L-1, i-1]\n elif k != 0 and L == 0:\n s[k, L, i] = z[k-1, i-1]\n elif k != 0 and L != 0 and k != L:\n s[k, L, i] = z[k-1, i-1] - z[L-1, i-1]\n return s","def find_path(sources, goals, connections):\n visited = set()\n expanded = set()\n queue = deque()\n\n for s in sources:\n queue.appendleft([s])\n\n while queue:\n path = queue.pop()\n head = path[-1]\n visited.add(head)\n\n neighbours = [o for (i, o) in connections if i == head]\n for neighbour in neighbours:\n if neighbour in goals:\n return path + [neighbour]\n elif neighbour not in visited:\n queue.appendleft(path + [neighbour])\n\n return []","def tripTrian(G):\r\n\tn = len(G)\r\n\ttrip = set()\r\n\ttrian = set()\r\n\tfor u in range(n):\r\n\t\tfor v in G[u]:\r\n\t\t\tfor w in G[v]:\r\n\t\t\t\tif v !=u and v!=w and u != w:\r\n\t\t\t\t\ttrip.add((u,v,w))\r\n\t\t\t\t\ts = getTrip((u,v,w))\r\n\t\t\t\t\tif u in G[w]:\r\n\t\t\t\t\t\ttrip.add((u,v,w))\r\n\t\t\t\t\t\ttrian.update(s)\r\n\t\t\t\t\t\ttrip.update(s)\r\n\t\t\t\t\telse:\r\n\t\t\t\t\t\ttrip.update(s)\r\n\r\n\treturn (len(trian)/6,len(trip)/6)","def get_possible_paths(graph, _from, _to):\n # Mark all the nodes as not visited\n visited = []\n\n # Create an array to store paths\n paths = []\n\n # Call the recursive helper function to get all paths\n get_all_paths_helper(graph, _from, _to, visited, [], paths)\n\n return paths","def loadPaths(self):\n for ij in self.link:\n self.link[ij].flow = 0\n for p in self.path:\n for ij in self.path[p].links:\n self.link[ij].flow += self.path[p].flow\n for ij in self.link:\n self.link[ij].updateCost()\n for p in self.path:\n self.path[p].updateCost()","def find_all_paths(graph, src, dst):\n paths = _find_all_paths(graph, src, dst)\n if not paths:\n return None\n minimum_length = min([len(path) for path in paths])\n return deque([path for path in paths if len(path) == minimum_length])","def calculate_paths(self):\n self.paths = {}\n for node in self.nodes:\n path = self.find_path_to_root(node)\n self.paths[node] = path\n self.path_dists[node] = [0.0] + [n.branch for n in path[1:]]","def all_shortest_paths(self, start_node, end_node):\n s=self.min_dist(start_node,end_node)\n return self.all_paths(start_node,end_node,s,[])","def get_path(prevs, goal, start):\n path = OD({goal: 0})\n cur = goal\n while cur != start:\n (cost, node) = prevs.get(cur)\n if node == None or node in path:\n print(\"ERROR: No path found from %s -> %s\" % (start, goal))\n return (0, None)\n path[node] = path[cur] + cost\n cur = node\n return (path[start], path.keys()[::-1])","def _iterative_cutting(g, p):\n\n to_be_processed = [g]\n K = math.ceil(len(g.nodes()) / p)\n\n res = []\n while len(to_be_processed) > 0:\n\n g = to_be_processed.pop()\n g_l, g_r = kernighan_lin_bisection(g, weight=\"rate\")\n\n for partition in g_l, g_r:\n if len(partition) > K:\n to_be_processed.append(g.subgraph(partition))\n else:\n res.append(partition)\n return res","def findPathsToBase(A,bSize):\n M,N = A.shape\n pressedPaths = []\n\n #For every two nodes in the base find all paths between them\n for b1 in range(bSize):\n for b2 in range(bSize):\n #Remove all other base nodes from the graph so that\n #we only find paths that go through the specialization set\n if b1 == b2:\n #In this case we are looking for a cycle.\n mask = [b1]+list(range(bSize,N))\n newSize = len(mask) + 1\n reduA = np.zeros((newSize,newSize))\n #Because the networkx cycle finders don't do what we need\n #them to do, we create a new graph and find paths instead\n reduA[:-1,:-1] = A[mask,:][:,mask]\n #Remove ingoing edges from the base node and add to new node\n reduA[-1,:] = reduA[0,:]\n reduA[0,:] = np.zeros(newSize)\n G = nx.DiGraph(reduA.T)\n #Find paths from the base node to the new node\n #same as finding all the cycles\n paths = list(nx.all_simple_paths(G,0,newSize-1))\n\n else:\n mask = [b1,b2]+list(range(bSize,N))\n reduA = A[mask,:][:,mask]\n #Remove base node interactions\n reduA[:2,:2] = np.zeros((2,2))\n G = nx.DiGraph(reduA.T)\n paths = list(nx.all_simple_paths(G,0,1))\n\n #Process Paths so that they make sense when the rest of the base\n #set is added to the graph\n for p in paths:\n if p != []:\n if b1 == b2:\n p = np.array(p) + bSize-1\n else:\n p = np.array(p) + bSize-2\n p[[0,-1]] = [b1, b2]\n pressedPaths.append(p)\n\n return pressedPaths","def pathTo(self, v): # O(# edges returned)\n if self.hasNegativeCycle():\n raise Exception(\"Negative cost cycle exists\")\n if not self.hasPathTo(v): return None\n path = [] # new Stack<DirectedEdge>()\n e = self._edgeTo[v]\n while e is not None: \n path.append(e) # push(e)\n e = self._edgeTo[e.get_from()]\n return path","def shortest_path_search(start, successors, is_goal):\r\n if is_goal(start):\r\n return [start]\r\n\r\n explored = set() # set of states we have visited\r\n frontier = [ [start] ] # ordered list of paths we have blazed\r\n while frontier:\r\n path = frontier.pop(0)\r\n s = path[-1]\r\n for (state, action) in successors(s).items():\r\n if state not in explored:\r\n explored.add(state)\r\n path2 = path + [action, state]\r\n if is_goal(state):\r\n return path2\r\n else:\r\n frontier.append(path2)\r\n return Fail","def constructShortestPath(s, t, pred):\r\n path = [t]\r\n\r\n while t != s:\r\n t = pred[s][t]\r\n \r\n if t is None:\r\n return None\r\n path.insert(0, t)\r\n \r\n return path","def shorter_path(start, goal):\n if start == goal:\n return [start]\n explored = set() \n queue = [ [start] ] \n while queue:\n path = queue.pop(0)\n s = path[-1]\n for state, action in bj_subway[s].items():\n if state not in explored:\n explored.add(state)\n path2 = path + [action, state]\n if state == goal:\n\t\t\t\t\t# print path2\n\t\t\t\t\t# for x in queue:\n\t\t\t\t\t# print x\n\t\t\t\t\treturn path2\n else:\n queue.append(path2)\n return []","def chordless_path(G, t, Q, P, master_Q):\n s = P.popleft()\n if t in G[s]:\n Q.append(t)\n master_Q.append(Q)\n return\n for v in G[s]:\n if v is not P[0]:\n # Determine if there is a vt-Path in G \\ (N(s) \\ v)\n vertices_to_remove = list(G[s].keys())\n vertices_to_remove.remove(v)\n removed_graph = remove_vertices(G, vertices_to_remove)\n comp_ptr = components(removed_graph)\n # Make sure they are in the same component\n if comp_ptr[t] == v or comp_ptr[v] == t:\n bfs_route = bfs_path(removed_graph, v, t)\n new_q = Q.copy()\n new_q.append(v)\n chordless_path(removed_graph, t, new_q, bfs_route, master_Q)\n next_vert = P[0]\n Q.append(next_vert)\n # Find G \\ (N(s) \\ nxt(s))\n vertices_to_remove = list(G[s].keys())\n vertices_to_remove.remove(next_vert)\n chordless_path(remove_vertices(G, vertices_to_remove), t, Q, P, master_Q)","def Optimum_prun_based_routing(self, S, D, L):\n if self.has_path(S, D):\n \n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w') \n Opt_path = Shortest_path\n PathConcave_cost = self.max_path_cost(Shortest_path, 'c1') \n while len(Shortest_path) != 0:\n path_cost = self.additive_path_cost(Shortest_path, 'w') \n if path_cost <= L:\n \"\"\"go to concave cost\"\"\"\n PathConcave_cost = self.max_path_cost(Shortest_path, 'c1') \n self.G = self.rm_edge_constraint(PathConcave_cost) # remove all links where the concave link is greater than PathConcave_cost\n \n Opt_path = Shortest_path\n if self.has_path(S, D):\n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w')\n else:\n Shortest_path = [] \n else:\n break \n else:\n self.logger.info('No path from %s to %s', S, D)\n PathConcave_cost = 0\n Opt_path = []\n return PathConcave_cost, Opt_path","def generateNumsets(G):\n # paths = []\n #\n # path = [0]\n # for edge in nx.dfs_edges(G, 0):\n # if edge[0] == path[-1]:\n # path.append(edge[1])\n # else:\n # paths.append(path)\n # search_index = 2\n # while search_index <= len(path):\n # if edge[0] == path[-search_index]:\n # path = path[:-search_index + 1] + [edge[1]]\n # break\n # search_index += 1\n # else:\n # raise Exception(\"Wrong path structure?\", path, edge)\n # paths.append(path)\n # return paths\n\n \"\"\"\n Trying to use itertools LMAO\n \"\"\"\n # paths = []\n #\n # for path in itertools.combinations(G.nodes, 5):\n # paths.append(path)\n # return paths\n\n \"\"\"\n Generating paths using graph\n \"\"\"\n paths = []\n n = len(G.nodes)\n for source in range(n):\n for target in range(source+1, n):\n paths.extend([path for path in nx.all_simple_paths(G, source=source, target=target)])\n return paths\n\n # return paths","def get_paths_from(self, symbol):\n to_return = []\n visitation_queue = [self.head]\n while len(visitation_queue) != 0:\n visiting = visitation_queue.pop(0)\n for elem in visiting.children:\n visitation_queue.append(elem)\n if symbol in visiting.inputs:\n v = visiting\n model_trail = []\n while v.parent is not None:\n model_trail.append(v.m)\n v = v.parent\n to_return.append(SymbolPath(visiting.inputs, model_trail))\n return to_return","def _shortest_path(G, start, end, sp_cache):\n if (start, end) in SP_TABLE:\n return sp_cache[(start, end)]\n elif (end, start) in SP_TABLE:\n return sp_cache[(end, start)]\n else:\n D, P = _dijkstra(G, start, end)\n path = []\n temp = end\n while 1:\n path.append(end)\n if end == start: break\n end = P[end]\n path.reverse()\n sp_cache[(start, temp)] = path\n return path","def find_best_path(self, paths, sw, util, duration, time_now):\n bestpath = None\n bestpathmetric = None # [0,1] lower means better path\n bestpathlen = None # lower -> better path\n candidatepaths = []\n \n assert len(paths) == 2\n \n path_to_shift, shift_by = self.calculate_what_to_shift(paths, sw)\n\n pathmetrics = {}\n paths_by_length = {}\n metrics = []\n metricpaths = {}\n for path in paths:\n metric, length = self.compute_path_metric(sw, path, 0, 0, local_contrib=True)\n paths_by_length[length] = path\n metrics.append(metric)\n assert metric >= 0 \n pathmetrics[\" \".join(path)] = metric\n metricpaths[metric] = path\n\n logging.debug(\"SS FBP PATH METRICS:, %s\", str(metricpaths))\n if path_to_shift == None:\n # return shortest path\n logging.debug(\"SS FBP Returning LOCAL: %s\", str((paths_by_length[min(paths_by_length.keys())],0)))\n return (paths_by_length[min(paths_by_length.keys())], 0)\n \n \n path_to_shift_metric = pathmetrics.pop(\" \".join(path_to_shift))\n path_to_receive_metric = pathmetrics.pop(pathmetrics.keys()[0])\n logging.debug(\"SS FBP Path to Recv: %s\", str(metricpaths[path_to_receive_metric]))\n\n if (path_to_receive_metric == 0):\n logging.debug(\"SS FBP EARLY Returning : %s\", str((metricpaths[min(metrics)], 0)))\n return (metricpaths[min(metrics)], 0)\n else:\n current_ratio = path_to_shift_metric * 1.0 / path_to_receive_metric\n\n logging.debug(\"SS FBP CURRENT RATIO: %s\", str(current_ratio))\n\n\n goal_path_to_shift_metric = path_to_shift_metric * (1 - (shift_by * self.alpha))\n goal_path_to_receive_metric = path_to_receive_metric + (path_to_shift_metric * (shift_by * self.alpha))\n\n if (goal_path_to_receive_metric == 0):\n # large number for practical purposes\n goal_ratio = 100000\n else:\n goal_ratio = goal_path_to_shift_metric * 1.0 / goal_path_to_receive_metric\n\n logging.debug(\"SS FBP GOAL RATIO: %s\", str(goal_ratio))\n\n # FINALLY DECIDE WHICH PATH TO RETURN BASED ON GOAL-Current RATIO\n if goal_ratio - current_ratio < 0:\n # return path with lower utiliztion\n logging.debug(\"SS FBP LOWER Returning : %s\", str((metricpaths[min(metrics)], 0)))\n return (metricpaths[min(metrics)], 0)\n \n if goal_ratio - current_ratio > 0:\n # return path with higher utilization\n logging.debug(\"SS FBP HIGHER Returning : %s\", str((metricpaths[max(metrics)], 0)))\n return (metricpaths[max(metrics)], 0)\n\n if goal_ratio - current_ratio == 0:\n # return shortest path\n logging.debug(\"SS FBP Returning LOCAL: %s\",\n str((paths_by_length[min(paths_by_length.keys())], 0)))\n return (paths_by_length[min(paths_by_length.keys())], 0)","def get_segments(self, sets=None):\n if sets is None:\n if self.sets is not None:\n sets = self.sets\n else:\n raise ValueError(\"sets and self.sets attributes are None, \\\n you need either to pass an origin argument to get_segments or \\\n to use get_filtration method before\")\n segments = []\n for s in sets:\n if self.epsilon <= s.getRelevance():\n t, a, b = s.getPosition()\n for i, seg in enumerate(segments):\n tp, ap, bp = seg\n if t >= tp and bp > a:\n bp = a\n elif t <= tp and ap < b:\n ap = b\n segments[i] = (tp, ap, bp)\n segments.append((t, a, b))\n return segments","def path(self):\r\n node, p = self, []\r\n while node:\r\n p.append(node)\r\n node = node.parent\r\n yield from reversed(p)","def path_search(start, goal):\n if start == goal:\n return [start]\n explored = set() \n queue = [ [start, ('', 0)] ]\n while queue:\n path = queue.pop(0)\n s = path[-2]\n linenum, changetimes = path[-1]\n if s == goal:\n print changetimes\n print path\n for x in queue:\n print x\n return path\n for state, action in bj_subway[s].items():\n if state not in explored:\n linechange = changetimes + 1\n explored.add(state)\n if linenum != action:\n linechange += 2\n path2 = path[:-1] + [action, state, (action, linechange)]\n queue.append(path2)\n queue.sort(key=lambda path:path[-1][-1])\n return []","def get_dfs(self, s):\n results = []\n # mark all the vertices as not visited\n visited = [False] * (len(self.graph))\n self._dfs_recursive(s, visited, results)\n return results","def calculate_path(self):\n #Se repite el ciclo para el número especificado de veces\n for i in range(self.iterations):\n for ant in self.ants:\n ant.setup_ant()\n while not ant.final_node_reached:\n #Seleccion aleatoria del nodo a visitar\n node_to_vist = self.select_next_node(self.map.nodes_array[int(ant.actual_node[0])][int(ant.actual_node[1])])\n #Mover la hormiga al siguiente nodo seleccionado al azar\n ant.move_ant(node_to_visit)\n #Compruebe si se ha alcanzado la solución\n ant.is_final_node_reached()\n #Agregar la ruta resultante a la lista de rutas\n self.add_to_path_results(self.delete_loops(ant.get_visited_nodes()))\n # Habilitar a la hormiga para otra busqueda\n ant.enable_start_new_path()\n \n # Actualizar el nivel global de feromonas\n self.pheromone_update()\n self.best_result = self.paths[0]\n\n #Vaciar la lista de rutas\n self.empty_paths()\n print('Iteration: ', i, 'lenght of the path: ', len(self.best_result))\n return self.best_result","def fastest_path_estimation(sol):\n\n class Path:\n def __init__(self, places, graph):\n self.g = 0 # current cost\n self.graph = graph\n self.visited = [places[0]] # list of already visited attractions\n self.not_visited = copy.deepcopy(places[1:]) # list of attractions not yet visited\n\n def __lt__(self, other):\n return self.g < other.g\n\n def add(self, idx):\n # add the cost\n self.g += self.graph[self.visited[-1], idx]\n # add the to the visited place and remove from the unvisited places\n self.visited.append(idx)\n self.not_visited.remove(idx)\n\n def add_to_heap_queue(path):\n # custom function to add to heap queue sorted by the solution's cost\n heappush(h_queue, path)\n\n if len(sol.not_visited) == 0:\n return 0\n elif len(sol.not_visited) == 1:\n return sol.graph[sol.visited[-1], sol.not_visited[0]]\n\n c = sol.visited[-1]\n pm = sol.not_visited[-1]\n # the heap queue of solution sorted by their cost - change all to tuples with g for dijkstra\n h_queue = []\n\n # the places to use for the graph\n sub_search_places = [c]\n sub_search_places.extend(sol.not_visited)\n\n # push the first \"node\" in the queue\n add_to_heap_queue(Path(sub_search_places, sol.graph))\n while True:\n # take the next solution with the shortest cost\n path = heappop(h_queue)\n # if it contains destination, stop and return that solution\n if pm in path.visited:\n return path.g\n # create a new solution for each neighbor of the current vertex and add it to heap queue\n for place in path.not_visited:\n new_path = copy.deepcopy(path)\n new_path.add(place)\n add_to_heap_queue(new_path)","def path(g): #g: graph\n marked = set()\n nodes = set(g.nodes) \n output = list()\n def recursive(g):\n for i in nodes.copy():\n d = dependents(g,i)\n if (not d) or all(dd in marked for dd in d):\n output.append((i,g.nodes[i]['word']))\n marked.add(i)\n nodes.remove(i)\n if nodes==set([0]):\n break\n recursive(g)\n break\n recursive(g)\n return output","def update_trip_path(trip_mpois, paths, graph):\n n_nodes = len(trip_mpois)\n # adjacency matrix\n new_paths = np.zeros(shape=(n_nodes, n_nodes))\n\n # iterate through all the nodes and create a list of nodes with sequential id\n for i, node1 in enumerate(trip_mpois):\n for j, node2 in enumerate(trip_mpois):\n new_paths[i, j] = paths[node1, node2]\n\n # new_paths = new_paths/np.max(new_paths[new_paths < _INF])\n # new_paths[np.isinf(new_paths)] = _INF\n\n # create a dummy edge between end and start node with weight 0\n new_paths[1,0] = -_INF\n # new_paths[0,1] = _INF\n\n shortest_path = None\n if n_nodes > 5:\n shortest_path, dist = tsp.solve(n_nodes, new_paths)\n # shortest_path = range(n_nodes)\n else:\n shortest_path = range(n_nodes)\n\n trip_path = np.array(trip_mpois)[shortest_path]\n\n if ___DEBUG:\n fname = 'dump/' + str(n_nodes) + '.dist'\n np.savetxt(fname, new_paths, fmt='%.6f')\n \n mpoi_pos = np.zeros(shape=(n_nodes,2))\n \n for i, node in enumerate(trip_mpois):\n pos_3d = graph.vs[node]['position']\n assert node == graph.vs[node].index\n mpoi_pos[i,:] = pos_3d[:2]\n\n fname = 'dump/' + str(n_nodes) + '.pos'\n np.savetxt(fname, mpoi_pos)\n \n # print trip_mpois, trip_path\n\n return trip_path"],"string":"[\n \"def get_paths_for_flow(F, s, f):\\n links = [((u, v), split_ratio) \\n for (flow_id, u, v), split_ratio in F.items() \\n if flow_id == f and u == s and split_ratio > 0.001]\\n return links\",\n \"def get_paths_for_flow(F, s, f):\\n links = [((u, v), split_ratio) \\n for (flow_id, u, v), split_ratio in F.items() \\n if flow_id == f and u == s and split_ratio > 0.001]\\n return links\",\n \"def paths(p, q):\\n if (p, q) == (0, 0):\\n return [((0, 0),)]\\n answer = list()\\n if p > 0:\\n west = paths(p - 1, q)\\n for path in west:\\n answer.append(path + ((p, q),))\\n if q > 0:\\n south = paths(p, q - 1)\\n for path in south:\\n answer.append(path + ((p, q),))\\n return answer\",\n \"def get_spliced_paths(self, p_i, p_j):\\n p_i_nodes = self.get_path_nodes(p_i)[1:-1]\\n p_j_nodes = self.get_path_nodes(p_j)[1:-1]\\n # we will splice at least common node\\n print(\\\"Path we are attempting to splice\\\")\\n print(p_i, p_j)\\n print(p_i_nodes, p_j_nodes)\\n if len(set(p_i_nodes).intersection(set(p_j_nodes))) == 0:\\n print(\\\"no overlap\\\")\\n common_node = min(set(p_i_nodes).intersection(set(p_j_nodes)))\\n # find where p_i gets to this node\\n index_i = 0\\n index_j = 0\\n for index, arc in enumerate(p_i):\\n destin = self.arc_info[arc][\\\"destin\\\"]\\n if destin == common_node:\\n index_i = index + 1\\n break\\n for index, arc in enumerate(p_j):\\n destin = self.arc_info[arc][\\\"destin\\\"]\\n if destin == common_node:\\n index_j = index + 1\\n break\\n p_i_prime = p_j[:index_j] + p_i[index_i:]\\n p_j_prime = p_i[:index_i] + p_j[index_j:]\\n return (p_i_prime, p_j_prime)\",\n \"def get_path_matrix(self, seed, p):\\n neighbors = [] # 8 neighbors of the pixel being processed\\n processed = set() # Processed point\\n cost = {seed: 0.0} # Accumulated cost, initialized with seed to itself\\n paths = {}\\n p_x, p_y = p\\n s_x, s_y = seed\\n min_x = max(0, min(p_x - self.extra_space, s_x - self.extra_space))\\n max_x = min(self.x_lim, max(p_x + self.extra_space, s_x + self.extra_space))\\n min_y = max(0, min(p_y - self.extra_space, s_y - self.extra_space))\\n max_y = min(self.y_lim, max(p_y + self.extra_space, s_y + self.extra_space))\\n \\n\\n self.n_processed = 0\\n \\n while cost:\\n # Expand the minimum cost point\\n p = min(cost, key=cost.get)\\n neighbors = self._get_neighbors(p, min_x, max_x, min_y, max_y)\\n processed.add(p)\\n\\n # Record accumulated costs and back tracking point for newly expanded points\\n for q in [x for x in neighbors if x not in processed]:\\n temp_cost = cost[p] + self._weighted_cost(p, q)\\n if q in cost:\\n if temp_cost < cost[q]:\\n cost.pop(q)\\n else:\\n cost[q] = temp_cost\\n processed.add(q)\\n paths[q] = p\\n \\n # Pop traversed points\\n cost.pop(p)\\n \\n self.n_processed += 1\\n \\n return paths\",\n \"def dfs_path(graph, s, goals=[]):\\n visited = []\\n parents = [None]*(len(graph))\\n boundary = [s]\\n while len(boundary) > 0:\\n v = boundary.pop()\\n visited += [v]\\n for w in neighbours(v, graph):\\n if w not in visited and w not in boundary:\\n boundary.append(w)\\n parents[w] = v\\n return get_path(parents, goals[0], goals[1])\",\n \"def bfs_path(graph, s, goals=[]):\\n visited = []\\n parents = [None]*len(graph)\\n boundary = [s]\\n while len(boundary) > 0:\\n v = boundary.pop(0)\\n visited += [v]\\n for w in neighbours(v, graph):\\n if w not in visited and w not in boundary:\\n boundary.append(w)\\n parents[w] = v\\n #w's parent\\n # put w's parent in the partent list\\n return get_path(parents, goals[0], goals[1])\",\n \"def possible(self):\\n return [tuple(path) for path in nx.all_shortest_paths(self._gpm.Graph, source=self.source, target=self.target)]\",\n \"def get_all_paths(self):\\n seen = set()\\n for v in self:\\n # v in self returns all nodes in the pathgraph\\n if v not in seen:\\n # self [v] returns a path containing v. If the v does not belong to a path\\n # a singleton path [v] is returned\\n yield self[v]\\n seen.update(self[v])\",\n \"def DRPathValidation(self, flow, p):\\n\\t\\tpath_rate_lst = []\\n\\n\\t\\tarr_time = flow[3]\\n\\t\\tend_time = flow[3] + flow[4]\\n\\t\\tedge_lst = [(p[i], p[i+1]) for i in xrange(len(p)-1)]\\n\\t\\t# Calculate the bottlenecked rate at each event point\\n\\t\\tfor evt in self.event_lst:\\n\\t\\t\\tmin_rate = float('inf')\\n\\t\\t\\tfor e in edge_lst:\\n\\t\\t\\t\\tif evt in self.rate_lst[e].keys() and self.rate_lst[e][evt] < min_rate:\\n\\t\\t\\t\\t\\tmin_rate = self.rate_lst[e][evt]\\n\\t\\t\\tif min_rate < float('inf'):\\n\\t\\t\\t\\tpath_rate_lst.append((evt, min_rate))\\n\\n\\t\\t# Calculate the cumulative size over the bottleneck rates between arr_time and end_time\\n\\t\\tprev_time = arr_time\\n\\t\\tprev_rate = 0\\n\\t\\tcum_size = 0\\n\\t\\trate_alloc = [(-1, 0)]\\t# Start from time -1 with rate 0, so as a benchmark from the beginning\\n\\t\\tfor time, rate in path_rate_lst:\\n\\t\\t\\t# Each time period is from prev_time -> min{time, end_time}\\n\\t\\t\\tif time > prev_time:\\n\\t\\t\\t\\tif time < end_time:\\n\\t\\t\\t\\t\\tcum_size += prev_rate * (time - prev_time)\\n\\t\\t\\t\\t\\tcur_ed_time = time\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tcum_size += prev_rate * (end_time - prev_time)\\n\\t\\t\\t\\t\\tcur_ed_time = end_time\\n\\t\\t\\t\\trate_alloc.append((prev_time, prev_rate))\\n\\n\\t\\t\\t\\tif cum_size >= flow[2]:\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\telif time >= end_time:\\n\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\tprev_time = time\\n\\t\\t\\tprev_rate = rate\\n\\n\\t\\t# If it can carry the flow size before deadline\\n\\t\\tif cum_size >= flow[2]:\\n\\t\\t\\tcum_size -= prev_rate * (cur_ed_time - prev_time)\\n\\t\\t\\tnew_end_time = float(flow[2] - cum_size) / prev_rate + prev_time\\n\\t\\t\\t# Add the finish rate onto the allocation list\\n\\t\\t\\trate_alloc.append((new_end_time, 0))\\n\\n\\t\\t\\treturn True, edge_lst, self.DRAllocTrim(rate_alloc), new_end_time\\n\\n\\t\\t# If not, return the minimum edge regarding the cumulative size\\n\\t\\tedge, size = self.DRFindMinimalEdge(flow, edge_lst)\\n\\t\\treturn False, edge, size\",\n \"def paths_set(self):\\n return self._paths_set\",\n \"def paths(self, start):\\n # This is probably a little slow\\n tupadd = lambda p, v: (p[0] + v[0], p[1] + v[1])\\n # First, we'll check adjacency moves.\\n adj = [tupadd(start, v) for v in DIRECTIONS]\\n yield from (p for p in adj if self.board(p) == 0)\\n # Now we check repeated hops.\\n # We do this by a breadth first search.\\n\\n #TODO: Consensus on legality of hopping back to start and \\\"skipping\\\"\\n visited = set(adj)\\n to_visit = [start]\\n while len(to_visit):\\n pt = to_visit.pop(0)\\n if pt in visited:\\n continue\\n\\n # We have to actually move a piece\\n # But this stops us from considering \\\"start\\\" even if we can\\n # make some hops and get back to start\\n if pt is not start:\\n yield pt\\n \\n visited.add(pt)\\n # Compute the hop directions\\n dirs = ((tupadd(pt, v), tupadd(pt, tupadd(v, v))) for v in DIRECTIONS)\\n to_visit.extend(\\n dest for over, dest in dirs\\n if self.board(over) > 0\\n and self.board(dest) == 0\\n and dest not in visited\\n and over != start\\n )\",\n \"def get_processed_flow_paths(self) -> Path:\\n return self.flow_data_paths.processed_flow_path\",\n \"def IteratePaths(self):\\n self.w = self.setwage(self.K, self.N)\\n self.r = self.setrate(self.K, self.N)\\n self.b = self.benefit(self.N)\\n\\n a1, aT = [-1,], []\\n\\n for q in range(self.Nq):\\n if q == 0:\\n self.apath[-1] = 0.2\\n elif q == 1:\\n self.apath[-1] = 0.3\\n else:\\n self.apath[-1] = max(0,aT[-1]-(aT[-1]-aT[-2])*a1[-1]/(a1[-1]-a1[-2]))\\n \\n self.npath[-1] = 0\\n self.cpath[-1] = self.apath[-1]*(1+self.r) + self.b\\n\\n for y in range(-2,-(self.T+1),-1): # y = -2, -3,..., -60\\n self.apath[y], self.npath[y], self.cpath[y] = self.DirectSolve(y)\\n\\n aT.append(self.apath[-1])\\n a1.append(self.apath[-self.T])\\n if (fabs(self.apath[-self.T])<self.tol):\\n break\\n for y in range(-1,-(self.T+1),-1):\\n self.upath[y] = self.util(self.cpath[y],self.npath[y])\",\n \"def bfs_paths(self, start: str, goal: str) -> List[Path]:\\n queue = [(start, [start])]\\n while queue:\\n (node, path) = queue.pop(0)\\n if node not in self.graph:\\n yield []\\n for _next in set(self.graph[node]) - set(path):\\n if _next == goal:\\n yield path + [_next]\\n elif _next in self.graph:\\n queue.append((_next, path + [_next]))\",\n \"def choose_paths_without_simulation(FT, output_dir, iteration, pathset_paths_df, pathset_links_df, veh_trips_df):\\n simulation_iteration = 0\\n ######################################################################################################\\n FastTripsLogger.info(\\\" Step 1. Find out board/alight times for all pathset links from vehicle times\\\")\\n\\n # could do this just to chosen path links but let's do this to the whole pathset\\n pathset_links_df = Assignment.find_passenger_vehicle_times(pathset_links_df, veh_trips_df)\\n\\n # instead of flag_missed_transfers(), set these to pathfinding results\\n pathset_links_df[Assignment.SIM_COL_PAX_ALIGHT_DELAY_MIN] = 0\\n pathset_links_df[Assignment.SIM_COL_PAX_A_TIME ] = pathset_links_df[Passenger.PF_COL_PAX_A_TIME]\\n pathset_links_df[Assignment.SIM_COL_PAX_B_TIME ] = pathset_links_df[Passenger.PF_COL_PAX_B_TIME]\\n pathset_links_df[Assignment.SIM_COL_PAX_LINK_TIME ] = pathset_links_df[Passenger.PF_COL_LINK_TIME]\\n pathset_links_df[Assignment.SIM_COL_PAX_WAIT_TIME ] = pathset_links_df[Passenger.PF_COL_WAIT_TIME]\\n pathset_links_df[Assignment.SIM_COL_PAX_MISSED_XFER ] = 0\\n\\n ######################################################################################################\\n FastTripsLogger.info(\\\" Step 2. Calculate costs and probabilities for all pathset paths\\\")\\n (pathset_paths_df, pathset_links_df) = PathSet.calculate_cost(\\n iteration, simulation_iteration, Assignment.STOCH_DISPERSION,\\n pathset_paths_df, pathset_links_df, FT.passengers.trip_list_df,\\n FT.transfers.transfers_df, FT.tazs.walk_df, FT.tazs.drive_df, veh_trips_df, FT.stops)\\n\\n ######################################################################################################\\n FastTripsLogger.info(\\\" Step 3. Choose a path for each passenger from their pathset\\\")\\n\\n # Choose path for each passenger -- pathset_paths_df and pathset_links_df will now have\\n # SIM_COL_PAX_CHOSEN >=0 for chosen paths/path links\\n (num_passengers_arrived, num_chosen, pathset_paths_df, pathset_links_df) = Passenger.choose_paths(\\n True, # choose for everyone\\n iteration, simulation_iteration,\\n pathset_paths_df, pathset_links_df)\\n\\n # Write the pathsets\\n Passenger.write_paths(output_dir, iteration, simulation_iteration, pathset_paths_df, False, Assignment.OUTPUT_PATHSET_PER_SIM_ITER)\\n Passenger.write_paths(output_dir, iteration, simulation_iteration, pathset_links_df, True, Assignment.OUTPUT_PATHSET_PER_SIM_ITER)\\n\\n # write the final chosen paths for this iteration\\n chosen_links_df = Passenger.get_chosen_links(pathset_links_df)\\n chosen_links_df[\\\"iteration\\\"] = iteration\\n Util.write_dataframe(chosen_links_df, \\\"chosen_links_df\\\", os.path.join(output_dir, \\\"chosenpaths_links.csv\\\"), append=(iteration>1))\\n chosen_links_df.drop([\\\"iteration\\\"], axis=1, inplace=True)\\n\\n chosen_paths_df = Passenger.get_chosen_links(pathset_paths_df)\\n chosen_paths_df[\\\"iteration\\\"] = iteration\\n Util.write_dataframe(chosen_paths_df, \\\"chosen_paths_df\\\", os.path.join(output_dir, \\\"chosenpaths_paths.csv\\\"), append=(iteration>1))\\n chosen_paths_df.drop([\\\"iteration\\\"], axis=1, inplace=True)\\n\\n return (num_passengers_arrived, pathset_paths_df, pathset_links_df)\",\n \"def CostOfPath( self, P, D ):\\n cost = 0\\n for tup in P:\\n cost += D[tup[0]][tup[1]]\\n return cost\",\n \"def all_paths(self, node, destination, dist, path):\\n\\n d=self.dict()\\n p=[]\\n for i in range(len(path)):\\n p.append(path[i])\\n p.insert(len(p),node)\\n \\n if len(p)-1==dist:\\n if node==destination:\\n return p\\n else:\\n return None\\n\\n my_paths=[]\\n\\n for a in d[node]:\\n if a not in p:\\n p1=self.all_paths(a,destination,dist,p)\\n\\n if p1!=None:\\n if isinstance(p1[0],list):\\n for i in range(len(p1)):\\n my_paths.append(p1[i])\\n else:\\n my_paths.append(p1)\\n\\n if len(my_paths)!=0:\\n return my_paths\\n else:\\n return None\",\n \"def assign_paths(output_dir, FT):\\n Assignment.write_configuration(output_dir)\\n\\n # write the initial load profile, iteration 0\\n veh_trips_df = FT.trips.get_full_trips()\\n pathset_paths_df = None\\n pathset_links_df = None\\n\\n # write 0-iter vehicle trips\\n Assignment.write_vehicle_trips(output_dir, 0, veh_trips_df)\\n\\n for iteration in range(1,Assignment.ITERATION_FLAG+1):\\n FastTripsLogger.info(\\\"***************************** ITERATION %d **************************************\\\" % iteration)\\n\\n if (Assignment.PATHFINDING_TYPE == Assignment.PATHFINDING_TYPE_READ_FILE) and (iteration == 1):\\n FastTripsLogger.info(\\\"Reading paths from file\\\")\\n (new_pathset_paths_df, new_pathset_links_df) = FT.passengers.read_passenger_pathsets(output_dir, include_asgn=False)\\n num_paths_found = Assignment.number_of_pathsets(new_pathset_paths_df)\\n\\n else:\\n num_paths_found = Assignment.generate_pathsets(FT, pathset_paths_df, veh_trips_df, output_dir, iteration)\\n (new_pathset_paths_df, new_pathset_links_df) = FT.passengers.setup_passenger_pathsets(iteration, FT.stops,\\n FT.trips.trip_id_df, FT.trips.trips_df, FT.routes.modes_df,\\n FT.transfers, FT.tazs, Assignment.PREPEND_ROUTE_ID_TO_TRIP_ID)\\n # write pathfinding results to special PF results file\\n Passenger.write_paths(output_dir, 0, 0, new_pathset_paths_df, False, Assignment.OUTPUT_PATHSET_PER_SIM_ITER)\\n Passenger.write_paths(output_dir, 0, 0, new_pathset_links_df, True, Assignment.OUTPUT_PATHSET_PER_SIM_ITER)\\n\\n # write performance info right away in case we crash, quit, etc\\n FT.performance.write(output_dir, iteration)\\n\\n if Assignment.PATHFINDING_EVERYONE:\\n pathset_paths_df = new_pathset_paths_df\\n pathset_links_df = new_pathset_links_df\\n else:\\n (pathset_paths_df, pathset_links_df) = Assignment.merge_pathsets(FT.passengers.pathfind_trip_list_df, pathset_paths_df, pathset_links_df, new_pathset_paths_df, new_pathset_links_df)\\n num_paths_found = Assignment.number_of_pathsets(pathset_paths_df)\\n\\n if Assignment.SIMULATION:\\n FastTripsLogger.info(\\\"****************************** SIMULATING *****************************\\\")\\n (num_passengers_arrived, pathset_paths_df, pathset_links_df, veh_trips_df) = \\\\\\n Assignment.simulate(FT, output_dir, iteration, pathset_paths_df, pathset_links_df, veh_trips_df)\\n else:\\n # if we're not simulating, we can still calculate costs and choose paths\\n FastTripsLogger.info(\\\"****************************** CHOOSING PATHS WITHOUT SIMULATING *****************************\\\")\\n\\n (num_passengers_arrived, pathset_paths_df, pathset_links_df) = \\\\\\n Assignment.choose_paths_without_simulation(FT, output_dir, iteration, pathset_paths_df, pathset_links_df, veh_trips_df)\\n\\n # Set new schedule\\n FT.trips.stop_times_df = veh_trips_df\\n\\n Assignment.write_vehicle_trips(output_dir, iteration, veh_trips_df)\\n\\n if Assignment.OUTPUT_PASSENGER_TRAJECTORIES:\\n PathSet.write_path_times(Passenger.get_chosen_links(pathset_links_df), output_dir)\\n\\n # capacity gap stuff\\n num_bumped_passengers = num_paths_found - num_passengers_arrived\\n if num_paths_found > 0:\\n capacity_gap = 100.0*num_bumped_passengers/num_paths_found\\n else:\\n capacity_gap = 100\\n\\n FastTripsLogger.info(\\\"\\\")\\n FastTripsLogger.info(\\\" TOTAL ASSIGNED PASSENGERS: %10d\\\" % num_paths_found)\\n FastTripsLogger.info(\\\" ARRIVED PASSENGERS: %10d\\\" % num_passengers_arrived)\\n FastTripsLogger.info(\\\" MISSED PASSENGERS: %10d\\\" % num_bumped_passengers)\\n FastTripsLogger.info(\\\" CAPACITY GAP: %10.5f\\\" % capacity_gap)\\n\\n if False and capacity_gap < 0.001:\\n break\\n\\n # end for loop\",\n \"def find_path_all_bfs(graph,start,end):\\n\\tvisited = set()\\n\\twatched = set()\\n\\tpaths = []\\n\\n\\twatched.add(start)\\n\\n\\tnodes_queue = [(start,[start])]\\n\\twhile nodes_queue:\\n\\t\\tcurrent_node, path = nodes_queue.pop(0)\\n\\n\\t\\tvisited.add(current_node)\\n\\n\\t\\tif (current_node == end):\\n\\t\\t\\tpaths.append(path)\\n\\n\\t\\tfor adjacent_node in graph[current_node]:\\n\\t\\t\\tif (adjacent_node not in watched) and (adjacent_node not in visited):\\n\\t\\t\\t\\tnodes_queue.append((adjacent_node, path+[adjacent_node]))\\n\\n\\treturn paths\",\n \"def constructShortestPath(self):\\r\\n sp = []\\r\\n v = self.t\\r\\n while self.preds[v]: # is not None\\r\\n sp.append(v)\\r\\n v = self.preds[v]\\r\\n sp.append(self.s) # source\\r\\n sp.reverse() # to have the path from source to dest and not t to s\\r\\n return sp, self.graph.getCoords(sp)\",\n \"def find_paths(self, source: str, target: str, n_requested_paths: int = 3,\\n n_skipped_paths: int = 0) -> List[Tuple[List[str], float]]:\\n assert self.graph_handler\\n found_paths = []\\n for path in self._k_shortest_paths(self.graph_handler.graph, source, target, n_requested_paths,\\n weight=\\\"weight\\\", path_start=n_skipped_paths):\\n path_length = nx.path_weight(self.graph_handler.graph, path, \\\"weight\\\")\\n found_paths.append((path, path_length))\\n\\n return found_paths\",\n \"def allPairsShortestPath(g):\\r\\n #dist+pred will be dicts (key:vtx, val:dict->KEY:toVtx, VAL:dist/pred) \\r\\n dist = {}\\r\\n pred = {}\\r\\n #for all vertices, create dict values with vertex as key\\r\\n for u in g: \\r\\n dist[u] = {} \\r\\n pred[u] = {}\\r\\n #for all vertices, set init. dist+pred to all vertices, including self\\r\\n for v in g: \\r\\n dist[u][v] = sys.maxsize\\r\\n pred[u][v] = None\\r\\n\\r\\n #finish off init with obvious dist and pred to self as 0 and None\\r\\n dist[u][u] = 0\\r\\n pred[u][u] = None\\r\\n\\r\\n #for all vertices in graph for current vertex u, set obvious..\\r\\n #..neighboring direct dist and pred\\r\\n for v in g[u]:\\r\\n dist[u][v] = g[u][v]\\r\\n pred[u][v] = u\\r\\n\\r\\n #this is the heavy lifting to figure out...\\r\\n for mid in g:\\r\\n for u in g:\\r\\n for v in g:\\r\\n newlen = dist[u][mid] + dist[mid][v]\\r\\n if newlen < dist[u][v]:\\r\\n dist[u][v] = newlen\\r\\n pred[u][v] = pred[mid][v]\\r\\n\\r\\n return (dist,pred)\",\n \"def calculate_path(self):\\n\\n mid_states = []\\n\\n # Add in between states\\n for i in range(Constants.NUMBER_LAPS):\\n mid_states = mid_states + Constants.LAP_STATES\\n\\n # Concatenate beginning, middle and end states to obtain full path of states\\n self.path_states = Constants.BEGINNING_STATES + mid_states + Constants.END_STATES\\n\\n # Determine the amount of times that the smallbot will drive forward during the path\\n self.times_driven_forward = self.path_states.count('CREEP_FORWARD')\\n\\n print(\\\"Calculated path: \\\", self.path_states)\",\n \"def dfs_paths(graph, start, goal, method='dfs'):\\n \\n # Define the search method\\n stack_pop = -1\\n if method == 'bfs':\\n stack_pop = 0\\n \\n stack = [(start, [start])]\\n while stack:\\n (vertex, path) = stack.pop(stack_pop)\\n neighbors = node_neighbors(graph, vertex)\\n for next_node in set(neighbors) - set(path):\\n if next_node == goal:\\n yield path + [next_node]\\n else:\\n stack.append((next_node, path + [next_node]))\",\n \"def get_potential_pw_splice_pairs(self):\\n self.print_out()\\n path_pairs = []\\n for i, path_1 in enumerate(self.paths):\\n for j, path_2 in enumerate(self.paths):\\n if j != i:\\n p1_nodes = self.get_path_nodes(path_1)[1:-1]\\n p2_nodes = self.get_path_nodes(path_2)[1:-1]\\n if len(set(p1_nodes).intersection(set(p2_nodes))) != 0:\\n path_pairs.append((i,j))\\n path_pairs.sort()\\n return path_pairs\",\n \"def find_trip_based_pathset(iteration, pathset, hyperpath, trace):\\n # FastTripsLogger.debug(\\\"C++ extension start\\\")\\n # send it to the C++ extension\\n (ret_ints, ret_doubles, path_costs, process_num,\\n label_iterations, num_labeled_stops, max_label_process_count,\\n ms_labeling, ms_enumerating,\\n bytes_workingset, bytes_privateusage) = \\\\\\n _fasttrips.find_pathset(iteration, pathset.person_id_num, pathset.trip_list_id_num, hyperpath,\\n pathset.user_class, pathset.purpose, pathset.access_mode, pathset.transit_mode, pathset.egress_mode,\\n pathset.o_taz_num, pathset.d_taz_num,\\n 1 if pathset.outbound() else 0, float(pathset.pref_time_min),\\n 1 if trace else 0)\\n # FastTripsLogger.debug(\\\"C++ extension complete\\\")\\n # FastTripsLogger.debug(\\\"Finished finding path for person %s trip list id num %d\\\" % (pathset.person_id, pathset.trip_list_id_num))\\n pathdict = {}\\n row_num = 0\\n\\n for path_num in range(path_costs.shape[0]):\\n\\n pathdict[path_num] = {}\\n pathdict[path_num][PathSet.PATH_KEY_COST ] = path_costs[path_num, 0]\\n pathdict[path_num][PathSet.PATH_KEY_PROBABILITY] = path_costs[path_num, 1]\\n # List of (stop_id, stop_state)\\n pathdict[path_num][PathSet.PATH_KEY_STATES ] = []\\n\\n # print \\\"path_num %d\\\" % path_num\\n\\n # while we have unprocessed rows and the row is still relevant for this path_num\\n while (row_num < ret_ints.shape[0]) and (ret_ints[row_num, 0] == path_num):\\n # print row_num\\n\\n mode = ret_ints[row_num,2]\\n # todo\\n if mode == -100:\\n mode = PathSet.STATE_MODE_ACCESS\\n elif mode == -101:\\n mode = PathSet.STATE_MODE_EGRESS\\n elif mode == -102:\\n mode = PathSet.STATE_MODE_TRANSFER\\n elif mode == -103:\\n mode = Passenger.MODE_GENERIC_TRANSIT_NUM\\n\\n if hyperpath:\\n pathdict[path_num][PathSet.PATH_KEY_STATES].append( (ret_ints[row_num, 1], [\\n ret_doubles[row_num,0], # label,\\n Util.SIMULATION_DAY_START + datetime.timedelta(minutes=ret_doubles[row_num,1]), # departure/arrival time\\n mode, # departure/arrival mode\\n ret_ints[row_num,3], # trip id\\n ret_ints[row_num,4], # successor/predecessor\\n ret_ints[row_num,5], # sequence\\n ret_ints[row_num,6], # sequence succ/pred\\n datetime.timedelta(minutes=ret_doubles[row_num,2]), # link time\\n ret_doubles[row_num,3], # cost\\n Util.SIMULATION_DAY_START + datetime.timedelta(minutes=ret_doubles[row_num,4]) # arrival/departure time\\n ] ) )\\n else:\\n pathdict[path_num][PathSet.PATH_KEY_STATES].append( (ret_ints[row_num, 1], [\\n datetime.timedelta(minutes=ret_doubles[row_num,0]), # label,\\n Util.SIMULATION_DAY_START + datetime.timedelta(minutes=ret_doubles[row_num,1]), # departure/arrival time\\n mode, # departure/arrival mode\\n ret_ints[row_num,3], # trip id\\n ret_ints[row_num,4], # successor/predecessor\\n ret_ints[row_num,5], # sequence\\n ret_ints[row_num,6], # sequence succ/pred\\n datetime.timedelta(minutes=ret_doubles[row_num,2]), # link time\\n datetime.timedelta(minutes=ret_doubles[row_num,3]), # cost\\n Util.SIMULATION_DAY_START + datetime.timedelta(minutes=ret_doubles[row_num,4]) # arrival/departure time\\n ] ) )\\n row_num += 1\\n\\n perf_dict = { \\\\\\n Performance.PERFORMANCE_COLUMN_PROCESS_NUM : process_num,\\n Performance.PERFORMANCE_COLUMN_LABEL_ITERATIONS : label_iterations,\\n Performance.PERFORMANCE_COLUMN_NUM_LABELED_STOPS : num_labeled_stops,\\n Performance.PERFORMANCE_COLUMN_MAX_STOP_PROCESS_COUNT: max_label_process_count,\\n Performance.PERFORMANCE_COLUMN_TIME_LABELING_MS : ms_labeling,\\n Performance.PERFORMANCE_COLUMN_TIME_ENUMERATING_MS : ms_enumerating,\\n Performance.PERFORMANCE_COLUMN_TRACED : trace,\\n Performance.PERFORMANCE_COLUMN_WORKING_SET_BYTES : bytes_workingset,\\n Performance.PERFORMANCE_COLUMN_PRIVATE_USAGE_BYTES : bytes_privateusage\\n }\\n return (pathdict, perf_dict)\",\n \"def paths(self):\\n return self._visit(self.start)\",\n \"def get_special_paths(set_path: str, set_value, sp_to_label: Dict, label_to_ship: Dict):\\n additions = set()\\n if type(set_value) is not dict:\\n # If this path is already labelled as special, then check that the ship matched with it does fit\\n if set_path in sp_to_label:\\n if label_to_ship[sp_to_label[set_path]].check_fit(set_value):\\n return additions\\n\\n # If this is something a ship covers, add it as a special path\\n for ship in label_to_ship.values():\\n if ship.check_fit(set_value):\\n additions.add( (set_path, ship.get_label()) )\\n\\n # If this is a dict, recursively build the set of additional paths\\n else:\\n for k, v in set_value.items():\\n assert check_valid_key_name(k), \\\"Invalid Key: {}\\\".format(k)\\n if set_path != Path.rootPath():\\n child_path = \\\"{}.{}\\\".format(set_path, k)\\n else:\\n child_path = \\\".{}\\\".format(k)\\n child_add = get_special_paths(child_path, v, sp_to_label, label_to_ship)\\n additions = additions.union(child_add)\\n\\n return additions\",\n \"def path(l_s, l_f, leg_list):\\n # candidates =\\n return min(heuristic_path([l_s], l_f, leg_list, []), key = len)\",\n \"def dfs_paths_dict_recur(\\n graph: Mapping[Node, set[Node]],\\n start: Node,\\n goal: Node,\\n path: Optional[list[Node]] = None\\n) -> Iterable[list[Node]]:\\n if path is None:\\n path = [start]\\n if start == goal:\\n yield path\\n else:\\n for next_node in graph[start].difference(path):\\n next_path = path + [next_node]\\n yield from dfs_paths_dict_recur(graph, next_node, goal, next_path)\",\n \"def calc_critical_paths(self):\\n visited = set([])\\n nodes = set(self.get_leaves())\\n\\n while nodes:\\n n = nodes.pop()\\n n.update_critical_path(n.latency())\\n visited.add(n)\\n cp = n.critical_path\\n\\n for p in n.parents:\\n p.update_critical_path(cp + p.latency())\\n # if p not in visited:\\n nodes.add(p)\\n # visited.add(p)\\n\\n for d in n.serial_parents:\\n d.update_critical_path(cp + 1)\\n # if d not in visited:\\n nodes.add(d)\\n # visited.add(d)\",\n \"def split_path(self, path):\\n# import pdb;pdb.set_trace()\\n if len(path) < 2:\\n return [path]\\n\\n paths = [[path[0]]]\\n for i in range(1, len(path)-1):\\n p0 = path[i-1]\\n p1 = path[i]\\n p2 = path[i+1]\\n v1 = p0 - p1\\n v2 = p2 - p1\\n d = np.sum(v1 * v2)\\n if d > 0:\\n print('found cusp')\\n paths.append([])\\n paths[-1].append(p1)\\n paths[-1].append(path[-1])\\n paths = [np.stack(p, axis=0) for p in paths] \\n return paths\",\n \"def collect_paths(rllab_env: Env,\\n prob_meta: ProblemMeta,\\n get_action: Any,\\n n_paths: int,\\n max_len: int) -> Tuple[List[Path], float]:\\n assert max_len > 0\\n\\n paths = []\\n uenv = unwrap_env(rllab_env)\\n ospace = uenv.observation_space\\n tot_rew = 0.0\\n\\n for path_num in range(n_paths):\\n path = []\\n obs = rllab_env.reset()\\n done = False\\n\\n for step_num in range(max_len):\\n # TODO: some fraction of the time I should take a random action,\\n # and some fraction of the time I should take an LRTDP-recommended\\n # action. Maybe---need to think about the optimal thing to do here.\\n action, _ = get_action(obs)\\n path.append((ospace.unflatten(obs),\\n prob_meta.bound_acts_ordered[action]))\\n # done is true in both goal states and recognised dead ends\\n # info contains 'goal_reached' and 'progress', which can both be\\n # useful\\n obs, rew, done, info = rllab_env.step(action)\\n tot_rew += rew\\n if done:\\n break\\n else:\\n # Need to do this outside loop for last step so that we can get\\n # both beginning and end. Maybe it's better just to ignore last\\n # step?\\n path.append((ospace.unflatten(obs),\\n prob_meta.bound_acts_ordered[action]))\\n paths.append(path)\\n\\n npaths = len(paths)\\n succ_rate = tot_rew / npaths\\n\\n return paths, succ_rate\",\n \"def Sidetrack2Path(tree, sidetracks, s, t):\\n\\tvisited = set()\\t\\t# visited nodes\\n\\tpath = []\\t\\t# set of edges\\n\\tsidenodes = set(links[e][0] for e in sidetracks)\\t# nodes that needs to be sidetracked\\n\\tcurrent = s\\n\\twhile current != t:\\n\\t\\t# Loop detection\\n\\t\\tif current in visited:\\n\\t\\t\\treturn []\\n\\t\\telse:\\n\\t\\t\\tvisited.add(current)\\n\\t\\t# No loop is found yet, proceed one hop\\n\\t\\tif current in sidenodes:\\n\\t\\t\\tedge = [e for e in sidetracks if links[e][0] == current]\\n\\t\\t\\tcurrent = links[edge[0]][1]\\n\\t\\t\\tpath.append(edge[0])\\n\\t\\telse:\\n\\t\\t\\tedge = [i for i,e in enumerate(links) if e == (current,tree[current])]\\n\\t\\t\\tcurrent = links[edge[0]][1]\\n\\t\\t\\tpath.append(edge[0])\\n\\t# Destination reached. Return the path\\n\\treturn path\",\n \"def find_all_path(self, start_vertex, end_vertex, path=[]):\\n\\n graph = self.__graph_dict\\n path = path + [start_vertex]\\n if start_vertex == end_vertex:\\n return [path]\\n\\n if start_vertex not in graph:\\n return []\\n\\n paths = []\\n for vertex in graph[start_vertex]:\\n if vertex not in path:\\n extended_paths = self.find_all_path(vertex, end_vertex,path)\\n for p in extended_paths:\\n paths.append(p)\\n return paths\",\n \"def find_unique_paths(self, source: str, target: str, number: int = 3) -> List[Tuple[List[str], float]]:\\n assert self.graph_handler\\n counter = 0\\n path_tuple_list = list()\\n # # # Initialise iterator over shortest simple paths if it is either not set or source/target do not match\\n if not self._use_old_iterator or \\\\\\n self._unique_iterator_memory is None or \\\\\\n self._unique_iterator_memory[0][0][0] != source or \\\\\\n self._unique_iterator_memory[0][0][-1] != target:\\n path_iterator = iter(nx.shortest_simple_paths(self.graph_handler.graph, source, target, weight=\\\"weight\\\"))\\n # # # Find first path and its cost\\n old_path = next(path_iterator)\\n old_path_cost = nx.path_weight(self.graph_handler.graph, old_path, weight=\\\"weight\\\")\\n else:\\n path_iterator = self._unique_iterator_memory[1]\\n old_path = self._unique_iterator_memory[0][0]\\n old_path_cost = self._unique_iterator_memory[0][1]\\n\\n while counter < number:\\n same_cost = True\\n tmp_path_list: List[List[str]] = list()\\n # # # Collect all paths with same cost\\n # TODO: Parameter for max tmp paths\\n n_max_collected_paths = 10\\n while same_cost and len(tmp_path_list) < n_max_collected_paths:\\n # # # Append old path to tmp_path list\\n tmp_path_list.append(old_path)\\n # # # Get next path and its cost\\n new_path = next(path_iterator, None)\\n # # # Break loop if no path is returned\\n if new_path is None:\\n break\\n new_path_cost = nx.path_weight(self.graph_handler.graph, new_path, weight=\\\"weight\\\")\\n # # # Check if new cost different to old cost\\n if abs(old_path_cost - new_path_cost) > 1e-12:\\n same_cost = False\\n # # # Overwrite old path with new path\\n old_path = new_path\\n\\n # # # Append path with most nodes to tuple list and its cost\\n path_tuple_list.append((max(tmp_path_list, key=lambda x: len(x)), # pylint: disable=unnecessary-lambda\\n old_path_cost))\\n # # # Break counter loop if no more paths to target are found\\n if new_path is None:\\n break\\n old_path_cost = new_path_cost\\n counter += 1\\n # # # Store iterator and path info (list of nodes and length)\\n if new_path is not None:\\n self._unique_iterator_memory = ((new_path, new_path_cost), path_iterator)\\n return path_tuple_list\",\n \"def cycles(p: List[int]) -> List[Set[int]]:\\n validate_permutation(p)\\n\\n todo = list(range(len(p)))\\n cycles = []\\n\\n while todo:\\n start = todo.pop(0)\\n\\n cycle = (start,)\\n position = p[start]\\n\\n while position != start:\\n todo.remove(position)\\n cycle += (position, )\\n position = p[position]\\n\\n cycles.append(cycle)\\n\\n return cycles\",\n \"def get_easy_possible_paths(mario_position: tuple, princess_position: tuple) -> Set[tuple]:\\n # getting 'distance' between Mario and princess in coordinates\\n distance = np.subtract(princess_position, mario_position)\\n\\n # create required moves from distance\\n moves_list = []\\n for i in range(abs(distance[0])):\\n moves_list.append((1, 0) if distance[0] >= 0 else (-1, 0))\\n for i in range(abs(distance[1])):\\n moves_list.append((0, 1) if distance[1] >= 0 else (0, -1))\\n\\n # create possible paths from possible moves, using set to remove duplicates\\n all_paths_list = set(itertools.permutations(moves_list))\\n return all_paths_list\",\n \"def solution_path(self) -> list[State]:\",\n \"def scan_P__(P__):\\n\\n for _P_, P_ in pairwise(P__): # Iterate through pairs of lines.\\n _iter_P_, iter_P_ = iter(_P_), iter(P_) # Convert to iterators.\\n try:\\n _P, P = next(_iter_P_), next(iter_P_) # First pair to check.\\n except StopIteration: # No more up_fork-down_fork pair.\\n continue # To next pair of _P_, P_.\\n while True:\\n isleft, olp = comp_edge(_P, P) # Check for 4 different cases.\\n if olp and _P['sign'] == P['sign']:\\n _P['down_fork_'].append(P)\\n P['up_fork_'].append(_P)\\n try: # Check for stopping:\\n _P, P = (next(_iter_P_), P) if isleft else (_P, next(iter_P_))\\n except StopIteration: # No more up_fork - down_fork pair.\\n break # To next pair of _P_, P_.\\n\\n return [*flatten(P__)] # Flatten P__ before return.\",\n \"def find_all_path(self, start, end, path=[]):\\n path = path+[start]\\n if start == end:\\n return path\\n paths = []\\n for node in self.graph[start]:\\n if node not in path:\\n newpaths = self.find_path(node, end, path)\\n paths.append(newpaths)\\n return paths\",\n \"def all_DU_paths(CG, T):\\n path_to_visit = []\\n path_not_visited = []\\n for var in CG.var:\\n vert_var_in_defv=set()\\n vert_var_in_refv=set()\\n for vert in CG.vertices:\\n if var in vert.defv:\\n vert_var_in_defv.add(vert.label)\\n elif var in vert.refv:\\n vert_var_in_refv.add(vert.label)\\n couples = product(vert_var_in_defv, vert_var_in_refv)\\n for vert_def, vert_ref in couples:\\n #paths_remaining = list(CG.simple_partial_paths[(vert_def, vert_ref)])\\n path_to_visit += list(CG.simple_partial_paths[(vert_def, vert_ref)])\\n path_not_visited += list(CG.simple_partial_paths[(vert_def, vert_ref)])\\n for t in T:\\n path, variables = apply_path(CG, t)\\n vert_found = False\\n for label in path:\\n cur_vertice=find_vertice_with_label(CG,label)\\n if vert_def == label:\\n vert_found = True\\n\\n elif vert_ref == label and vert_found:\\n if path in path_not_visited:\\n path_not_visited.remove(path)\\n break\\n\\n elif vert_ref != label and var in cur_vertice.refv:\\n break\\n #print('Test failed')\\n #print(paths_remaining, var,vert_def, vert_ref, path)\\n #return False\\n\\n #if paths_remaining:\\n # print('Test failed')\\n # print(paths_remaining, var, vert_def, vert_ref, path)\\n # return False\\n\\n Graph.coverage_criteria2(path_to_visit, \\\"not_visited\\\", path_not_visited)\\n if path_not_visited:\\n print('Test failed')\\n \\n else:\\n print('Test passed')\\n return True\",\n \"def calculate_paths(topology):\\n nodes = topology['nodes']\\n edges = topology['links']\\n\\n dist = [[len(nodes) + 1 for x in range(len(nodes))] for y in range(len(nodes))]\\n paths = [[[] for x in range(len(nodes))] for y in range(len(nodes))]\\n\\n for e in edges.values():\\n s, d = int(e['source']), int(e['target'])\\n dist[s][d] = dist[d][s] = 1\\n paths[s][d] = [e['id']]\\n paths[d][s] = [e['id']]\\n\\n for k in range(len(nodes)):\\n for i in range(len(nodes)):\\n for j in range(len(nodes)):\\n if dist[i][k] + dist[k][j] < dist[i][j]:\\n dist[i][j] = dist[i][k] + dist[k][j]\\n paths[i][j] = paths[i][k] + paths[k][j]\\n return paths\",\n \"def getPaths(self):\\n return self.pathTuple\",\n \"def shortest_path(start, end):\\n\\n\\tmoves = rubik.quarter_twists\\n\\n\\t# Parent nodes: (Parent_State, move)\\n\\tstartParents = {}\\n\\tstartParents[start] = None # Start state has no parent\\n\\n\\t# Parent nodes: (Parent_State, move)\\n\\tendParents = {}\\n\\tendParents[end] = None # End state has no parent\\n\\n\\tstartFrontier = [] # Current frontier in start BFS\\n\\tendFrontier = [] # Current frontier in end BFS\\n\\n\\tstartFrontier.append(start) # Add start state as first and only node to generate next frontier\\n\\tendFrontier.append(end) # Add end state as first and only node to generate next frontier\\n\\n\\tif end in startParents:\\n\\t\\treturn [] # Start == End : No moves required\\n\\n\\t# We only have to search at most 14 levels in BFS\\n\\t# Two-way BFS therefore requires 7 concurrent levels from both states\\n\\tfor i in range(7):\\n\\n\\t\\tstartNextFrontier = [] # New empty set for new frontier to be discovered\\n\\t\\tfor state in startFrontier: # Iterate through each rubiks state in this frontier\\n\\t\\t\\tfor move in moves: # Apply each move to this state\\n\\t\\t\\t\\tnextState = rubik.perm_apply(move, state)\\n\\n\\t\\t\\t\\t# Makes sure this new state is not already in the Graph\\n\\t\\t\\t\\t# This skips nodes that were already permuted in another path,\\n\\t\\t\\t\\t# essentially trimming the Graph's leaves\\n\\t\\t\\t\\tif nextState not in startParents:\\n\\t\\t\\t\\t\\tstartParents[nextState] = (state, move) # Store this state's parent + move\\n\\t\\t\\t\\t\\tstartNextFrontier.append(nextState) # Create a node in the next frontier\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# Intersect of both Graphs, Intermediate state of path found\\n\\t\\t\\t\\tif nextState in endParents:\\n\\t\\t\\t\\t\\treturn solution(startParents, endParents, nextState)\\n\\n\\t\\tstartFrontier = startNextFrontier # Make the next frontier the current one\\n\\n\\t\\tendNextFrontier = [] # New empty set for new frontier to be discovered\\n\\t\\tfor state in endFrontier: # Iterate through each rubiks state in this frontier\\n\\t\\t\\tfor move in moves: # Apply each move to this state\\n\\t\\t\\t\\tnextState = rubik.perm_apply(move, state)\\n\\n\\t\\t\\t\\t# Makes sure this new state is not already in the Graph\\n\\t\\t\\t\\t# This skips nodes that were already permuted in another path,\\n\\t\\t\\t\\t# essentially trimming the Graph's leaves\\n\\t\\t\\t\\tif nextState not in endParents:\\n\\t\\t\\t\\t\\tendParents[nextState] = (state, move) # Store this state's parent + move\\n\\t\\t\\t\\t\\tendNextFrontier.append(nextState) # Create a node in the next frontier\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# Intersect of both Graphs, Intermediate state of path found\\n\\t\\t\\t\\tif nextState in startParents:\\n\\t\\t\\t\\t\\treturn solution(startParents, endParents, nextState)\\n\\n\\t\\tendFrontier = endNextFrontier # Make the next frontier the current one\\n\\n\\treturn None\",\n \"def FindAllPaths(graph, start, end, path=[]):\\n path = path + [start]\\n if start == end:\\n return [path]\\n if start not in graph:\\n return None\\n paths = []\\n for node in graph[start]:\\n if node not in path:\\n newpaths = find_all_paths(graph, node, end, path)\\n for newpath in newpaths:\\n paths.append(newpath)\\n return paths\",\n \"def get_overlapping_path_pairs(self):\\n path_pairs = []\\n for i, path_1 in enumerate(self.paths):\\n for j, path_2 in enumerate(self.paths):\\n if j != i:\\n if len(set(path_1).intersection(set(path_2))) != 0:\\n path_pairs.append((i,j))\\n path_pairs.sort()\\n return path_pairs\",\n \"def a_star_ng(graph, heuristic, start, goal):\\n path = []\\n queue = PriorityQueue()\\n queue.put((0, start))\\n visited = set(start)\\n\\n branch = {}\\n found = False\\n while not queue.empty():\\n item = queue.get()\\n current_cost = item[0]\\n current_node = item[1]\\n\\n if current_node == goal:\\n print('Found a path.')\\n found = True\\n break\\n else:\\n for next_node in graph[current_node]:\\n cost = graph.edges[current_node, next_node]['weight']\\n new_cost = current_cost + cost + heuristic(next_node, goal)\\n\\n if next_node not in visited:\\n visited.add(next_node)\\n queue.put((new_cost, next_node))\\n\\n branch[next_node] = (new_cost, current_node)\\n\\n path = []\\n path_cost = 0\\n if found:\\n # retrace steps\\n path = []\\n n = goal\\n path_cost = branch[n][0]\\n path.append(goal)\\n while branch[n][1] != start:\\n path.append(branch[n][1])\\n n = branch[n][1]\\n path.append(branch[n][1])\\n # Wanted the sets to have ints, but had floats, so casted them to int\\n path = [(int(p[0]), int(p[1])) for p in path]\\n return path[::-1], path_cost\",\n \"def find_all_paths(graph, current, destination, path=[]):\\n\\n path = path + [current]\\n\\n if current == destination:\\n return path\\n\\n # difference: instead of returning none, return an empty path\\n if current not in graph:\\n reutrn []\\n\\n # create a list for storing the results (because there will be > 1)\\n paths = []\\n\\n for node in graph[current]:\\n if node not in path:\\n # the change is to return a list of path lists, instead of one path\\n newpaths = find_all_paths(graph, node, destination, path)\\n # now, for each path returned, add it to the solutions list\\n for newpath in newpaths:\\n paths.append(newpath)\\n return paths\",\n \"def _points_to_paths(self, points):\\n prev = points[0]\\n result = []\\n for point in points[1:]:\\n path = specctraobj.Path()\\n path.aperture_width = self._from_pixels(1)\\n path.vertex.append(prev)\\n path.vertex.append(point)\\n result.append(path)\\n prev = point\\n return result\",\n \"def summarize_paths(trips):\\n\\t# get a set of distinct Path objects. We have to use equality rather than \\n\\t# hashing here. \\n\\titins = []\\n\\t# add all OTP paths to the Itinerary each belongs to, creating new ones\\n\\t# along the way \\n\\tfor trip in trips:\\n\\t\\tif trip.path not in itins:\\n\\t\\t\\titins.append( Itinerary(trip.path) )\\n\\t\\ti = itins.index(trip.path)\\n\\t\\titins[i].add_OTP_trip( trip )\\n\\t# remove any itineraries which have no travel times in the DB at all \\n\\tbad_itins = []\\n\\tfor i, itin in enumerate(itins):\\n\\t\\ttts = [ d for d in itin.departures if d.travel_time ]\\n\\t\\tif len(tts) == 0: bad_itins.append(i)\\n\\tfor i in reversed(bad_itins):\\n\\t\\titins.pop(i)\\n\\treturn itins\",\n \"def makePath(P, path, src, dst):\\n print(\\\"Path from \\\"+src+\\\" to \\\"+dst)\\n previousV = P[dst]\\n while previousV != src:\\n path.push(previousV)\\n temp = previousV\\n previousV = P[temp]\\n path.push(previousV)\\n for i in range(path.getCount()):\\n print(path.pop())\",\n \"def find_all_paths(graph, start, end, path=[]):\\n path = path + [start]\\n if start == end:\\n return [path]\\n paths = []\\n for node in graph[start]:\\n newpaths = find_all_paths(graph, node, end, path)\\n paths += newpaths\\n return paths\",\n \"def shortest_path_search(start, successors, is_goal):\\n if is_goal(start):\\n return [start]\\n explored = set()\\n frontier = [ [start] ] \\n while frontier:\\n path = frontier.pop(0)\\n s = path[-1]\\n for (state, action) in successors(s).items():\\n if state not in explored:\\n explored.add(state)\\n path2 = path + [action, state]\\n if is_goal(state):\\n return path2\\n else:\\n frontier.append(path2)\\n return Fail\",\n \"def getPaths(self):\\n\\n trafficEndPoints = []\\n # A job denotes a traffic flow, which corresponds to an iperf task.\\n for job in self.config.trace.jobs:\\n trafficEndPoints.append((job['src'], job['dst']))\\n\\n # Obtain details about user-specified non-default links.\\n configuredLinks = []\\n for linkInfo in self.config.topoData['linkInfos']:\\n configuredLinks.append((linkInfo['src'], linkInfo['dst']))\\n\\n paths = None\\n spec = self.config.topoData['flowSpec']\\n if spec == 'shortest_path':\\n # export paths info and create routing conf using shortest paths\\n adjFile = self.config.adjacencyFile\\n writeAdjList(self.net, adjFile)\\n info(\\\"**** [G2]: adjacency list written to file\\\", adjFile, \\\"\\\\n\\\")\\n\\n outfile = os.path.join(self.config.outPath, SHORTEST_PATH_FILE)\\n paths = generateShortestPaths(adjFile, outfile, trafficEndPoints, configuredLinks)\\n info(\\\"**** [G2]: shortest paths written to file\\\", outfile, \\\"\\\\n\\\")\\n # Note: Since there can be multiple shortest paths between two endpoints, solution could vary.\\n elif \\\".json\\\" in spec:\\n info(\\\"**** [G2]: reading path info from\\\", spec, \\\"\\\\n\\\")\\n paths = readFromPathFile(spec)\\n else:\\n paths = None\\n return paths\",\n \"def select_paths(self, dpaths=None):\\r\\n \\r\\n locs = [] # Find list of starting locs\\r\\n if len(dpaths) == 0:\\r\\n return [], []\\r\\n \\r\\n for dpath in dpaths:\\r\\n locs.append(dpath.path[0]) # Get starting loc\\r\\n \\r\\n start_locs = self.get_starts(locs=locs)\\r\\n start_paths = [] # Get paths with these starting locs\\r\\n other_paths = []\\r\\n for dpath in dpaths:\\r\\n if dpath.path[0] in start_locs:\\r\\n start_paths.append(dpath)\\r\\n else:\\r\\n other_paths.append(dpath)\\r\\n last = self.get_val(\\\"last\\\")\\r\\n if last is 0 or last == \\\"\\\":\\r\\n last = len(dpaths)\\r\\n closed_tour = self.get_val(\\\"closed_tour\\\")\\r\\n not_tour = self.get_val(\\\"not_tour\\\")\\r\\n comp = self.get_val(\\\"comp\\\") \\r\\n not_comp = self.get_val(\\\"not_comp\\\") \\r\\n\\r\\n arr_list = start_paths\\r\\n other_list = other_paths\\r\\n if closed_tour or not_tour:\\r\\n a_list = []\\r\\n o_list = []\\r\\n for ad in arr_list:\\r\\n used = False\\r\\n is_tour = ad.is_closed_tour\\r\\n if closed_tour:\\r\\n if is_tour:\\r\\n a_list.append(ad)\\r\\n used = True\\r\\n if not_tour:\\r\\n if not is_tour:\\r\\n a_list.append(ad)\\r\\n used = True\\r\\n if not used:\\r\\n o_list.append(ad)\\r\\n arr_list = a_list\\r\\n other_list += o_list \\r\\n \\r\\n if comp or not_comp:\\r\\n a_list = []\\r\\n o_list = []\\r\\n for ad in arr_list:\\r\\n used = False\\r\\n is_comp = ad.is_complete_tour\\r\\n if comp:\\r\\n if is_comp:\\r\\n a_list.append(ad)\\r\\n used = True\\r\\n if not_comp:\\r\\n if not is_comp:\\r\\n a_list.append(ad)\\r\\n used = True\\r\\n if not used:\\r\\n o_list.append(ad)\\r\\n arr_list = a_list\\r\\n other_list += o_list\\r\\n self.prev_arr_list = arr_list \\r\\n return arr_list, other_list\",\n \"def shortest_path_search(start, successors, is_goal):\\n if is_goal(start): return [start]\\n explored = set()\\n frontier = [[start]]\\n while frontier:\\n path = frontier.pop(0)\\n s = path[-1]\\n for (state,action) in successors(s).items():\\n if state not in explored:\\n explored.add(state)\\n npath = path + [action,state]\\n if is_goal(state): return npath\\n else: frontier.append(npath)\\n return []\",\n \"def sample_endpoint_conditioned_path(\\n initial_state, final_state, path_length, P):\\n # get the size of the state space and do some input validation\\n MatrixUtil.assert_transition_matrix(P)\\n nstates = len(P)\\n if not (0 <= initial_state < nstates):\\n raise ValueError('invalid initial state')\\n if not (0 <= final_state < nstates):\\n raise ValueError('invalid final state')\\n # take care of edge cases\\n if path_length == 0:\\n return []\\n elif path_length == 1:\\n if initial_state != final_state:\\n raise ValueError('unequal states for a path of length one')\\n return [initial_state]\\n elif path_length == 2:\\n return [initial_state, final_state]\\n # sample the path\\n path = [initial_state]\\n for i in range(path_length-2):\\n remaining_power = path_length - 2 - i\\n M = linalg.matrix_power(P, remaining_power)\\n previous_state = path[i]\\n weight_state_pairs = []\\n for state_index in range(nstates):\\n weight = 1\\n weight *= P[previous_state, state_index]\\n weight *= M[state_index, final_state]\\n weight_state_pairs.append((weight, state_index))\\n next_state = Util.weighted_choice(weight_state_pairs)\\n path.append(next_state)\\n path.append(final_state)\\n return path\",\n \"def _find_all_paths(self, start_vertex: str, end_vertex: str, path=[]):\\n path = path + [start_vertex]\\n if start_vertex == end_vertex:\\n return [path]\\n\\n paths = []\\n for vertex in self.graph[start_vertex]:\\n if vertex not in path:\\n extended_paths = self._find_all_paths(vertex,\\n end_vertex,\\n path)\\n for p in extended_paths:\\n paths.append(p)\\n return paths\",\n \"def get_k_shortest_paths(env: RailEnv,\\n source_position: Tuple[int, int],\\n source_direction: int,\\n target_position=Tuple[int, int],\\n k: int = 1, debug=False) -> List[Tuple[Waypoint]]:\\n\\n # P: set of shortest paths from s to t\\n # P =empty,\\n shortest_paths: List[Tuple[Waypoint]] = []\\n\\n # countu: number of shortest paths found to node u\\n # countu = 0, for all u in V\\n count = {(r, c, d): 0 for r in range(env.height) for c in range(env.width) for d in range(4)}\\n\\n # B is a heap data structure containing paths\\n # N.B. use OrderedSet to make result deterministic!\\n heap: OrderedSet[Tuple[Waypoint]] = OrderedSet()\\n\\n # insert path Ps = {s} into B with cost 0\\n heap.add((Waypoint(source_position, source_direction),))\\n\\n # while B is not empty and countt < K:\\n while len(heap) > 0 and len(shortest_paths) < k:\\n if debug:\\n print(\\\"iteration heap={}, shortest_paths={}\\\".format(heap, shortest_paths))\\n # – let Pu be the shortest cost path in B with cost C\\n cost = np.inf\\n pu = None\\n for path in heap:\\n if len(path) < cost:\\n pu = path\\n cost = len(path)\\n u: Waypoint = pu[-1]\\n if debug:\\n print(\\\" looking at pu={}\\\".format(pu))\\n\\n # – B = B − {Pu }\\n heap.remove(pu)\\n # – countu = countu + 1\\n\\n urcd = (*u.position, u.direction)\\n count[urcd] += 1\\n\\n # – if u = t then P = P U {Pu}\\n if u.position == target_position:\\n if debug:\\n print(\\\" found of length {} {}\\\".format(len(pu), pu))\\n shortest_paths.append(pu)\\n\\n # – if countu ≤ K then\\n # CAVEAT: do not allow for loopy paths\\n elif count[urcd] <= k:\\n possible_transitions = env.rail.get_transitions(*urcd)\\n if debug:\\n print(\\\" looking at neighbors of u={}, transitions are {}\\\".format(u, possible_transitions))\\n # for each vertex v adjacent to u:\\n for new_direction in range(4):\\n if debug:\\n print(\\\" looking at new_direction={}\\\".format(new_direction))\\n if possible_transitions[new_direction]:\\n new_position = get_new_position(u.position, new_direction)\\n if debug:\\n print(\\\" looking at neighbor v={}\\\".format((*new_position, new_direction)))\\n\\n v = Waypoint(position=new_position, direction=new_direction)\\n # CAVEAT: do not allow for loopy paths\\n if v in pu:\\n continue\\n\\n # – let Pv be a new path with cost C + w(u, v) formed by concatenating edge (u, v) to path Pu\\n pv = pu + (v,)\\n # – insert Pv into B\\n heap.add(pv)\\n\\n # return P\\n return shortest_paths\",\n \"def generate_paths(self, paths: list) -> list or int:\\n path_count = 0\\n new_paths = {}\\n # follow each path in the paths list\\n for path in paths:\\n # find neighbours from last position in each path\\n neighbours = self.neighbours(path[-1])\\n for neighbour in neighbours:\\n if neighbour in self.queue.values():\\n continue # if neighbour in queue, go to next neighbour\\n # find grid value of neighbour\\n grid_value = self.grid[neighbour[1]][neighbour[0]]\\n if grid_value == 1:\\n new_paths[path_count] = path.copy()\\n new_paths[path_count].append(neighbour) # add path to dict\\n self.queue[path_count + 1] = neighbour # add neighbour to queue\\n path_count += 1 # increase count of number of paths\\n if grid_value == 9:\\n return len(path)\\n\\n # roll dict out into list of paths\\n paths_store = [new_paths[key] for key in new_paths]\\n\\n return paths_store\",\n \"def expand_paths_by_nodes(self, paths):\\n paths_formatted = set()\\n # Expand each path\\n for path in paths:\\n if len(path) < 2:\\n continue\\n expanded_paths = set()\\n if self.include_entity:\\n relations_for_each_step = [[path[0]]]\\n else:\\n relations_for_each_step = []\\n for index in range(1, len(path)):\\n node1 = path[index-1]\\n node2 = path[index]\\n if (node1, node2) in self.pair_to_relations:\\n relations = self.pair_to_relations[(node1, node2)]\\n else:\\n print(node1, node2)\\n relations_for_each_step.append(relations)\\n if self.include_entity:\\n relations_for_each_step.append([node2])\\n expanded_paths.update(list(itertools.product(*relations_for_each_step)))\\n paths_formatted.update(expanded_paths)\\n return paths_formatted\",\n \"def get_TSP(graph):\\n # row - from, column - to\\n partial_cost = {}\\n prev_vertices = {}\\n n = len(graph)\\n vertices = frozenset(range(1, n))\\n for i in range(1, n):\\n partial_cost[(i, frozenset())] = graph[0][i]\\n prev_vertices[(i, frozenset())] = 0\\n for i in range(1, n - 1):\\n for s in frozenset(combinations(vertices, i)):\\n s = frozenset(s)\\n for j in vertices - s:\\n partial_cost[j, frozenset(s)], prev_vertices[j, frozenset(s)] = get_min_cost_and_opt_prev(graph, partial_cost, j, s)\\n partial_cost[0, vertices], prev_vertices[0, vertices] = get_min_cost_and_opt_prev(graph, partial_cost, 0, vertices)\\n path = get_path(prev_vertices, vertices)\\n return path, partial_cost[0, vertices]\",\n \"def find_paths(self, source, destination, closed=None):\\n if closed is None:\\n closed = set()\\n closed.add(source)\\n links = {x.trusted for x in self._tau\\n if x.truster == source and x.trusted not in closed}\\n if len(links) == 0: # base\\n return []\\n if destination in links: # base\\n return [[Trust(source, destination)]]\\n # recurse\\n retval = []\\n for link in links:\\n linkpaths = self.find_paths(link, destination, closed)\\n for path in linkpaths:\\n path.insert(0, Trust(source, link))\\n retval += linkpaths\\n\\n for path in retval:\\n if None in path:\\n retval.remove(path)\\n if len(retval) == 0:\\n return []\\n return retval\",\n \"def path(self): # Path taken to reach Goal\\n node, path_back = self, []\\n while node:\\n path_back.append(node)\\n node = node.parent\\n return list(reversed(path_back))\",\n \"def shortest_path(start, end):\\n if start == end:\\n return []\\n \\n start_frontier = Queue.Queue()\\n start_parent = {}\\n start_level = {}\\n start_parent_move = {}\\n start_frontier.put(start)\\n start_level[start] = 0\\n start_parent[start] = None\\n start_parent_move[start] = None\\n \\n end_frontier = Queue.Queue()\\n end_parent = {}\\n end_level = {}\\n end_parent_move = {}\\n end_frontier.put(end)\\n end_level[end] = 0\\n end_parent[end] = None\\n end_parent_move[end] = None\\n \\n intersectFound = False\\n intersect = None\\n level = 0\\n while (True):\\n level += 1\\n# print (\\\"level = \\\" + str(level))\\n if not start_frontier.empty():\\n vertex = start_frontier.get()\\n for move in rubik.quarter_twists:\\n position = rubik.perm_apply(move,vertex)\\n if position not in start_parent:\\n# print (\\\"start permutation unvisited\\\")\\n start_parent[position] = vertex\\n start_level[position] = level\\n start_parent_move[position] = move\\n start_frontier.put(position)\\n if position in end_parent:\\n# print (\\\"position exists in end_parent\\\")\\n intersect = position\\n intersectFound = True\\n break\\n if intersectFound:\\n break\\n if not end_frontier.empty():\\n vertex = end_frontier.get()\\n for move in rubik.quarter_twists:\\n position = rubik.perm_apply(move,vertex)\\n if position not in end_parent:\\n# print (\\\"end permutation unvisited\\\")\\n end_parent[position] = vertex\\n end_level[position] = level\\n end_parent_move[position] = move\\n end_frontier.put(position)\\n if position in start_parent:\\n# print (\\\"position exists in start_parent\\\")\\n intersect = position\\n intersectFound = True\\n break\\n if intersectFound:\\n break\\n if end_frontier.empty() and start_frontier.empty():\\n break\\n \\n if intersect is None:\\n return None\\n \\n path = []\\n pos = intersect\\n while (start_parent[pos] is not None):\\n path.insert(0,start_parent_move[pos])\\n pos = start_parent[pos]\\n \\n pos = intersect\\n while (end_parent[pos] is not None):\\n move = rubik.perm_inverse(end_parent_move[pos])\\n path.append(move)\\n pos = end_parent[pos]\\n \\n# path = [None] * start_level[intersect]\\n# pos = intersect\\n# move = start_parent_move[pos]\\n# path[start_level[intersect]-1] = move\\n# for i in range(start_level[intersect]-2,-1,-1):\\n# if (start_parent[pos] is not None):\\n# pos = start_parent[pos]\\n# move = start_parent_move[pos]\\n# path[i] = move\\n# \\n# pos = intersect\\n# while (end_parent[pos] is not None):\\n# move = rubik.perm_inverse(end_parent_move[pos])\\n# path.append(move)\\n# pos = end_parent[pos]\\n \\n return path\",\n \"def calculate_paths(shape: Tuple[int, int], point: Tuple[int, int]) -> int:\\n\\tn, m = map(int, input().split())\\n\\tf = [[0] * (m+1) for i in range(n+1)]\\n\\tf[1][1] = 1\\n\\tfor i in range(2, n+1):\\n\\t\\tfor j in range(2, m + 1):\\n\\t\\t\\tf[i][j] = f[i-2][j-2] + f[i-2][j-1]\\n\\treturn n + m\",\n \"def shortest_path_search(start, successors, is_goal):\\r\\n if is_goal(start):\\r\\n return [start]\\r\\n explored = set()\\r\\n frontier = [ [start] ]\\r\\n while frontier:\\r\\n path = frontier.pop(0)\\r\\n s = path[-1]\\r\\n for (state, action) in successors(s).items():\\r\\n if state not in explored:\\r\\n explored.add(state)\\r\\n path2 = path + [action, state]\\r\\n if is_goal(state):\\r\\n return path2\\r\\n else:\\r\\n frontier.append(path2)\\r\\n return Fail\",\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 stairway_path(stairway: Sequence[Union[float, int]]) -> Union[float, int]:\\n # определяем начальный список стоимости перехода по ступенькам\\n sum_cost = [0 for _ in range(len(stairway))]\\n sum_cost[0] = stairway[0] # стоимость шага на 1 ступеньку\\n sum_cost[1] = stairway[1] # стоимость шага на 2 ступеньку\\n\\n for i in range(2, len(stairway)): # цикл начиная со 2 ступеньки и до конца лестницы\\n # соимость перехода = стоимость на i-ой ступ. + минимум стоимости(переход с i-2, переход с i-1)\\n sum_cost[i] = stairway[i] + min(sum_cost[i-2], sum_cost[i-1])\\n\\n return sum_cost[-1] # возвращаем последний результат в списке\",\n \"def _compute_ptdfs(self):\\n z = self._compute_z()\\n s = np.zeros([self.n_nodes, self.n_nodes, self.n_nodes])\\n for k in range(self.n_nodes):\\n for L in range(self.n_nodes):\\n for i in range(self.n_nodes):\\n if k == 0 and L != 0:\\n s[k, L, i] = -1 * z[L-1, i-1]\\n elif k != 0 and L == 0:\\n s[k, L, i] = z[k-1, i-1]\\n elif k != 0 and L != 0 and k != L:\\n s[k, L, i] = z[k-1, i-1] - z[L-1, i-1]\\n return s\",\n \"def find_path(sources, goals, connections):\\n visited = set()\\n expanded = set()\\n queue = deque()\\n\\n for s in sources:\\n queue.appendleft([s])\\n\\n while queue:\\n path = queue.pop()\\n head = path[-1]\\n visited.add(head)\\n\\n neighbours = [o for (i, o) in connections if i == head]\\n for neighbour in neighbours:\\n if neighbour in goals:\\n return path + [neighbour]\\n elif neighbour not in visited:\\n queue.appendleft(path + [neighbour])\\n\\n return []\",\n \"def tripTrian(G):\\r\\n\\tn = len(G)\\r\\n\\ttrip = set()\\r\\n\\ttrian = set()\\r\\n\\tfor u in range(n):\\r\\n\\t\\tfor v in G[u]:\\r\\n\\t\\t\\tfor w in G[v]:\\r\\n\\t\\t\\t\\tif v !=u and v!=w and u != w:\\r\\n\\t\\t\\t\\t\\ttrip.add((u,v,w))\\r\\n\\t\\t\\t\\t\\ts = getTrip((u,v,w))\\r\\n\\t\\t\\t\\t\\tif u in G[w]:\\r\\n\\t\\t\\t\\t\\t\\ttrip.add((u,v,w))\\r\\n\\t\\t\\t\\t\\t\\ttrian.update(s)\\r\\n\\t\\t\\t\\t\\t\\ttrip.update(s)\\r\\n\\t\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\t\\ttrip.update(s)\\r\\n\\r\\n\\treturn (len(trian)/6,len(trip)/6)\",\n \"def get_possible_paths(graph, _from, _to):\\n # Mark all the nodes as not visited\\n visited = []\\n\\n # Create an array to store paths\\n paths = []\\n\\n # Call the recursive helper function to get all paths\\n get_all_paths_helper(graph, _from, _to, visited, [], paths)\\n\\n return paths\",\n \"def loadPaths(self):\\n for ij in self.link:\\n self.link[ij].flow = 0\\n for p in self.path:\\n for ij in self.path[p].links:\\n self.link[ij].flow += self.path[p].flow\\n for ij in self.link:\\n self.link[ij].updateCost()\\n for p in self.path:\\n self.path[p].updateCost()\",\n \"def find_all_paths(graph, src, dst):\\n paths = _find_all_paths(graph, src, dst)\\n if not paths:\\n return None\\n minimum_length = min([len(path) for path in paths])\\n return deque([path for path in paths if len(path) == minimum_length])\",\n \"def calculate_paths(self):\\n self.paths = {}\\n for node in self.nodes:\\n path = self.find_path_to_root(node)\\n self.paths[node] = path\\n self.path_dists[node] = [0.0] + [n.branch for n in path[1:]]\",\n \"def all_shortest_paths(self, start_node, end_node):\\n s=self.min_dist(start_node,end_node)\\n return self.all_paths(start_node,end_node,s,[])\",\n \"def get_path(prevs, goal, start):\\n path = OD({goal: 0})\\n cur = goal\\n while cur != start:\\n (cost, node) = prevs.get(cur)\\n if node == None or node in path:\\n print(\\\"ERROR: No path found from %s -> %s\\\" % (start, goal))\\n return (0, None)\\n path[node] = path[cur] + cost\\n cur = node\\n return (path[start], path.keys()[::-1])\",\n \"def _iterative_cutting(g, p):\\n\\n to_be_processed = [g]\\n K = math.ceil(len(g.nodes()) / p)\\n\\n res = []\\n while len(to_be_processed) > 0:\\n\\n g = to_be_processed.pop()\\n g_l, g_r = kernighan_lin_bisection(g, weight=\\\"rate\\\")\\n\\n for partition in g_l, g_r:\\n if len(partition) > K:\\n to_be_processed.append(g.subgraph(partition))\\n else:\\n res.append(partition)\\n return res\",\n \"def findPathsToBase(A,bSize):\\n M,N = A.shape\\n pressedPaths = []\\n\\n #For every two nodes in the base find all paths between them\\n for b1 in range(bSize):\\n for b2 in range(bSize):\\n #Remove all other base nodes from the graph so that\\n #we only find paths that go through the specialization set\\n if b1 == b2:\\n #In this case we are looking for a cycle.\\n mask = [b1]+list(range(bSize,N))\\n newSize = len(mask) + 1\\n reduA = np.zeros((newSize,newSize))\\n #Because the networkx cycle finders don't do what we need\\n #them to do, we create a new graph and find paths instead\\n reduA[:-1,:-1] = A[mask,:][:,mask]\\n #Remove ingoing edges from the base node and add to new node\\n reduA[-1,:] = reduA[0,:]\\n reduA[0,:] = np.zeros(newSize)\\n G = nx.DiGraph(reduA.T)\\n #Find paths from the base node to the new node\\n #same as finding all the cycles\\n paths = list(nx.all_simple_paths(G,0,newSize-1))\\n\\n else:\\n mask = [b1,b2]+list(range(bSize,N))\\n reduA = A[mask,:][:,mask]\\n #Remove base node interactions\\n reduA[:2,:2] = np.zeros((2,2))\\n G = nx.DiGraph(reduA.T)\\n paths = list(nx.all_simple_paths(G,0,1))\\n\\n #Process Paths so that they make sense when the rest of the base\\n #set is added to the graph\\n for p in paths:\\n if p != []:\\n if b1 == b2:\\n p = np.array(p) + bSize-1\\n else:\\n p = np.array(p) + bSize-2\\n p[[0,-1]] = [b1, b2]\\n pressedPaths.append(p)\\n\\n return pressedPaths\",\n \"def pathTo(self, v): # O(# edges returned)\\n if self.hasNegativeCycle():\\n raise Exception(\\\"Negative cost cycle exists\\\")\\n if not self.hasPathTo(v): return None\\n path = [] # new Stack<DirectedEdge>()\\n e = self._edgeTo[v]\\n while e is not None: \\n path.append(e) # push(e)\\n e = self._edgeTo[e.get_from()]\\n return path\",\n \"def shortest_path_search(start, successors, is_goal):\\r\\n if is_goal(start):\\r\\n return [start]\\r\\n\\r\\n explored = set() # set of states we have visited\\r\\n frontier = [ [start] ] # ordered list of paths we have blazed\\r\\n while frontier:\\r\\n path = frontier.pop(0)\\r\\n s = path[-1]\\r\\n for (state, action) in successors(s).items():\\r\\n if state not in explored:\\r\\n explored.add(state)\\r\\n path2 = path + [action, state]\\r\\n if is_goal(state):\\r\\n return path2\\r\\n else:\\r\\n frontier.append(path2)\\r\\n return Fail\",\n \"def constructShortestPath(s, t, pred):\\r\\n path = [t]\\r\\n\\r\\n while t != s:\\r\\n t = pred[s][t]\\r\\n \\r\\n if t is None:\\r\\n return None\\r\\n path.insert(0, t)\\r\\n \\r\\n return path\",\n \"def shorter_path(start, goal):\\n if start == goal:\\n return [start]\\n explored = set() \\n queue = [ [start] ] \\n while queue:\\n path = queue.pop(0)\\n s = path[-1]\\n for state, action in bj_subway[s].items():\\n if state not in explored:\\n explored.add(state)\\n path2 = path + [action, state]\\n if state == goal:\\n\\t\\t\\t\\t\\t# print path2\\n\\t\\t\\t\\t\\t# for x in queue:\\n\\t\\t\\t\\t\\t# print x\\n\\t\\t\\t\\t\\treturn path2\\n else:\\n queue.append(path2)\\n return []\",\n \"def chordless_path(G, t, Q, P, master_Q):\\n s = P.popleft()\\n if t in G[s]:\\n Q.append(t)\\n master_Q.append(Q)\\n return\\n for v in G[s]:\\n if v is not P[0]:\\n # Determine if there is a vt-Path in G \\\\ (N(s) \\\\ v)\\n vertices_to_remove = list(G[s].keys())\\n vertices_to_remove.remove(v)\\n removed_graph = remove_vertices(G, vertices_to_remove)\\n comp_ptr = components(removed_graph)\\n # Make sure they are in the same component\\n if comp_ptr[t] == v or comp_ptr[v] == t:\\n bfs_route = bfs_path(removed_graph, v, t)\\n new_q = Q.copy()\\n new_q.append(v)\\n chordless_path(removed_graph, t, new_q, bfs_route, master_Q)\\n next_vert = P[0]\\n Q.append(next_vert)\\n # Find G \\\\ (N(s) \\\\ nxt(s))\\n vertices_to_remove = list(G[s].keys())\\n vertices_to_remove.remove(next_vert)\\n chordless_path(remove_vertices(G, vertices_to_remove), t, Q, P, master_Q)\",\n \"def Optimum_prun_based_routing(self, S, D, L):\\n if self.has_path(S, D):\\n \\n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w') \\n Opt_path = Shortest_path\\n PathConcave_cost = self.max_path_cost(Shortest_path, 'c1') \\n while len(Shortest_path) != 0:\\n path_cost = self.additive_path_cost(Shortest_path, 'w') \\n if path_cost <= L:\\n \\\"\\\"\\\"go to concave cost\\\"\\\"\\\"\\n PathConcave_cost = self.max_path_cost(Shortest_path, 'c1') \\n self.G = self.rm_edge_constraint(PathConcave_cost) # remove all links where the concave link is greater than PathConcave_cost\\n \\n Opt_path = Shortest_path\\n if self.has_path(S, D):\\n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w')\\n else:\\n Shortest_path = [] \\n else:\\n break \\n else:\\n self.logger.info('No path from %s to %s', S, D)\\n PathConcave_cost = 0\\n Opt_path = []\\n return PathConcave_cost, Opt_path\",\n \"def generateNumsets(G):\\n # paths = []\\n #\\n # path = [0]\\n # for edge in nx.dfs_edges(G, 0):\\n # if edge[0] == path[-1]:\\n # path.append(edge[1])\\n # else:\\n # paths.append(path)\\n # search_index = 2\\n # while search_index <= len(path):\\n # if edge[0] == path[-search_index]:\\n # path = path[:-search_index + 1] + [edge[1]]\\n # break\\n # search_index += 1\\n # else:\\n # raise Exception(\\\"Wrong path structure?\\\", path, edge)\\n # paths.append(path)\\n # return paths\\n\\n \\\"\\\"\\\"\\n Trying to use itertools LMAO\\n \\\"\\\"\\\"\\n # paths = []\\n #\\n # for path in itertools.combinations(G.nodes, 5):\\n # paths.append(path)\\n # return paths\\n\\n \\\"\\\"\\\"\\n Generating paths using graph\\n \\\"\\\"\\\"\\n paths = []\\n n = len(G.nodes)\\n for source in range(n):\\n for target in range(source+1, n):\\n paths.extend([path for path in nx.all_simple_paths(G, source=source, target=target)])\\n return paths\\n\\n # return paths\",\n \"def get_paths_from(self, symbol):\\n to_return = []\\n visitation_queue = [self.head]\\n while len(visitation_queue) != 0:\\n visiting = visitation_queue.pop(0)\\n for elem in visiting.children:\\n visitation_queue.append(elem)\\n if symbol in visiting.inputs:\\n v = visiting\\n model_trail = []\\n while v.parent is not None:\\n model_trail.append(v.m)\\n v = v.parent\\n to_return.append(SymbolPath(visiting.inputs, model_trail))\\n return to_return\",\n \"def _shortest_path(G, start, end, sp_cache):\\n if (start, end) in SP_TABLE:\\n return sp_cache[(start, end)]\\n elif (end, start) in SP_TABLE:\\n return sp_cache[(end, start)]\\n else:\\n D, P = _dijkstra(G, start, end)\\n path = []\\n temp = end\\n while 1:\\n path.append(end)\\n if end == start: break\\n end = P[end]\\n path.reverse()\\n sp_cache[(start, temp)] = path\\n return path\",\n \"def find_best_path(self, paths, sw, util, duration, time_now):\\n bestpath = None\\n bestpathmetric = None # [0,1] lower means better path\\n bestpathlen = None # lower -> better path\\n candidatepaths = []\\n \\n assert len(paths) == 2\\n \\n path_to_shift, shift_by = self.calculate_what_to_shift(paths, sw)\\n\\n pathmetrics = {}\\n paths_by_length = {}\\n metrics = []\\n metricpaths = {}\\n for path in paths:\\n metric, length = self.compute_path_metric(sw, path, 0, 0, local_contrib=True)\\n paths_by_length[length] = path\\n metrics.append(metric)\\n assert metric >= 0 \\n pathmetrics[\\\" \\\".join(path)] = metric\\n metricpaths[metric] = path\\n\\n logging.debug(\\\"SS FBP PATH METRICS:, %s\\\", str(metricpaths))\\n if path_to_shift == None:\\n # return shortest path\\n logging.debug(\\\"SS FBP Returning LOCAL: %s\\\", str((paths_by_length[min(paths_by_length.keys())],0)))\\n return (paths_by_length[min(paths_by_length.keys())], 0)\\n \\n \\n path_to_shift_metric = pathmetrics.pop(\\\" \\\".join(path_to_shift))\\n path_to_receive_metric = pathmetrics.pop(pathmetrics.keys()[0])\\n logging.debug(\\\"SS FBP Path to Recv: %s\\\", str(metricpaths[path_to_receive_metric]))\\n\\n if (path_to_receive_metric == 0):\\n logging.debug(\\\"SS FBP EARLY Returning : %s\\\", str((metricpaths[min(metrics)], 0)))\\n return (metricpaths[min(metrics)], 0)\\n else:\\n current_ratio = path_to_shift_metric * 1.0 / path_to_receive_metric\\n\\n logging.debug(\\\"SS FBP CURRENT RATIO: %s\\\", str(current_ratio))\\n\\n\\n goal_path_to_shift_metric = path_to_shift_metric * (1 - (shift_by * self.alpha))\\n goal_path_to_receive_metric = path_to_receive_metric + (path_to_shift_metric * (shift_by * self.alpha))\\n\\n if (goal_path_to_receive_metric == 0):\\n # large number for practical purposes\\n goal_ratio = 100000\\n else:\\n goal_ratio = goal_path_to_shift_metric * 1.0 / goal_path_to_receive_metric\\n\\n logging.debug(\\\"SS FBP GOAL RATIO: %s\\\", str(goal_ratio))\\n\\n # FINALLY DECIDE WHICH PATH TO RETURN BASED ON GOAL-Current RATIO\\n if goal_ratio - current_ratio < 0:\\n # return path with lower utiliztion\\n logging.debug(\\\"SS FBP LOWER Returning : %s\\\", str((metricpaths[min(metrics)], 0)))\\n return (metricpaths[min(metrics)], 0)\\n \\n if goal_ratio - current_ratio > 0:\\n # return path with higher utilization\\n logging.debug(\\\"SS FBP HIGHER Returning : %s\\\", str((metricpaths[max(metrics)], 0)))\\n return (metricpaths[max(metrics)], 0)\\n\\n if goal_ratio - current_ratio == 0:\\n # return shortest path\\n logging.debug(\\\"SS FBP Returning LOCAL: %s\\\",\\n str((paths_by_length[min(paths_by_length.keys())], 0)))\\n return (paths_by_length[min(paths_by_length.keys())], 0)\",\n \"def get_segments(self, sets=None):\\n if sets is None:\\n if self.sets is not None:\\n sets = self.sets\\n else:\\n raise ValueError(\\\"sets and self.sets attributes are None, \\\\\\n you need either to pass an origin argument to get_segments or \\\\\\n to use get_filtration method before\\\")\\n segments = []\\n for s in sets:\\n if self.epsilon <= s.getRelevance():\\n t, a, b = s.getPosition()\\n for i, seg in enumerate(segments):\\n tp, ap, bp = seg\\n if t >= tp and bp > a:\\n bp = a\\n elif t <= tp and ap < b:\\n ap = b\\n segments[i] = (tp, ap, bp)\\n segments.append((t, a, b))\\n return segments\",\n \"def path(self):\\r\\n node, p = self, []\\r\\n while node:\\r\\n p.append(node)\\r\\n node = node.parent\\r\\n yield from reversed(p)\",\n \"def path_search(start, goal):\\n if start == goal:\\n return [start]\\n explored = set() \\n queue = [ [start, ('', 0)] ]\\n while queue:\\n path = queue.pop(0)\\n s = path[-2]\\n linenum, changetimes = path[-1]\\n if s == goal:\\n print changetimes\\n print path\\n for x in queue:\\n print x\\n return path\\n for state, action in bj_subway[s].items():\\n if state not in explored:\\n linechange = changetimes + 1\\n explored.add(state)\\n if linenum != action:\\n linechange += 2\\n path2 = path[:-1] + [action, state, (action, linechange)]\\n queue.append(path2)\\n queue.sort(key=lambda path:path[-1][-1])\\n return []\",\n \"def get_dfs(self, s):\\n results = []\\n # mark all the vertices as not visited\\n visited = [False] * (len(self.graph))\\n self._dfs_recursive(s, visited, results)\\n return results\",\n \"def calculate_path(self):\\n #Se repite el ciclo para el número especificado de veces\\n for i in range(self.iterations):\\n for ant in self.ants:\\n ant.setup_ant()\\n while not ant.final_node_reached:\\n #Seleccion aleatoria del nodo a visitar\\n node_to_vist = self.select_next_node(self.map.nodes_array[int(ant.actual_node[0])][int(ant.actual_node[1])])\\n #Mover la hormiga al siguiente nodo seleccionado al azar\\n ant.move_ant(node_to_visit)\\n #Compruebe si se ha alcanzado la solución\\n ant.is_final_node_reached()\\n #Agregar la ruta resultante a la lista de rutas\\n self.add_to_path_results(self.delete_loops(ant.get_visited_nodes()))\\n # Habilitar a la hormiga para otra busqueda\\n ant.enable_start_new_path()\\n \\n # Actualizar el nivel global de feromonas\\n self.pheromone_update()\\n self.best_result = self.paths[0]\\n\\n #Vaciar la lista de rutas\\n self.empty_paths()\\n print('Iteration: ', i, 'lenght of the path: ', len(self.best_result))\\n return self.best_result\",\n \"def fastest_path_estimation(sol):\\n\\n class Path:\\n def __init__(self, places, graph):\\n self.g = 0 # current cost\\n self.graph = graph\\n self.visited = [places[0]] # list of already visited attractions\\n self.not_visited = copy.deepcopy(places[1:]) # list of attractions not yet visited\\n\\n def __lt__(self, other):\\n return self.g < other.g\\n\\n def add(self, idx):\\n # add the cost\\n self.g += self.graph[self.visited[-1], idx]\\n # add the to the visited place and remove from the unvisited places\\n self.visited.append(idx)\\n self.not_visited.remove(idx)\\n\\n def add_to_heap_queue(path):\\n # custom function to add to heap queue sorted by the solution's cost\\n heappush(h_queue, path)\\n\\n if len(sol.not_visited) == 0:\\n return 0\\n elif len(sol.not_visited) == 1:\\n return sol.graph[sol.visited[-1], sol.not_visited[0]]\\n\\n c = sol.visited[-1]\\n pm = sol.not_visited[-1]\\n # the heap queue of solution sorted by their cost - change all to tuples with g for dijkstra\\n h_queue = []\\n\\n # the places to use for the graph\\n sub_search_places = [c]\\n sub_search_places.extend(sol.not_visited)\\n\\n # push the first \\\"node\\\" in the queue\\n add_to_heap_queue(Path(sub_search_places, sol.graph))\\n while True:\\n # take the next solution with the shortest cost\\n path = heappop(h_queue)\\n # if it contains destination, stop and return that solution\\n if pm in path.visited:\\n return path.g\\n # create a new solution for each neighbor of the current vertex and add it to heap queue\\n for place in path.not_visited:\\n new_path = copy.deepcopy(path)\\n new_path.add(place)\\n add_to_heap_queue(new_path)\",\n \"def path(g): #g: graph\\n marked = set()\\n nodes = set(g.nodes) \\n output = list()\\n def recursive(g):\\n for i in nodes.copy():\\n d = dependents(g,i)\\n if (not d) or all(dd in marked for dd in d):\\n output.append((i,g.nodes[i]['word']))\\n marked.add(i)\\n nodes.remove(i)\\n if nodes==set([0]):\\n break\\n recursive(g)\\n break\\n recursive(g)\\n return output\",\n \"def update_trip_path(trip_mpois, paths, graph):\\n n_nodes = len(trip_mpois)\\n # adjacency matrix\\n new_paths = np.zeros(shape=(n_nodes, n_nodes))\\n\\n # iterate through all the nodes and create a list of nodes with sequential id\\n for i, node1 in enumerate(trip_mpois):\\n for j, node2 in enumerate(trip_mpois):\\n new_paths[i, j] = paths[node1, node2]\\n\\n # new_paths = new_paths/np.max(new_paths[new_paths < _INF])\\n # new_paths[np.isinf(new_paths)] = _INF\\n\\n # create a dummy edge between end and start node with weight 0\\n new_paths[1,0] = -_INF\\n # new_paths[0,1] = _INF\\n\\n shortest_path = None\\n if n_nodes > 5:\\n shortest_path, dist = tsp.solve(n_nodes, new_paths)\\n # shortest_path = range(n_nodes)\\n else:\\n shortest_path = range(n_nodes)\\n\\n trip_path = np.array(trip_mpois)[shortest_path]\\n\\n if ___DEBUG:\\n fname = 'dump/' + str(n_nodes) + '.dist'\\n np.savetxt(fname, new_paths, fmt='%.6f')\\n \\n mpoi_pos = np.zeros(shape=(n_nodes,2))\\n \\n for i, node in enumerate(trip_mpois):\\n pos_3d = graph.vs[node]['position']\\n assert node == graph.vs[node].index\\n mpoi_pos[i,:] = pos_3d[:2]\\n\\n fname = 'dump/' + str(n_nodes) + '.pos'\\n np.savetxt(fname, mpoi_pos)\\n \\n # print trip_mpois, trip_path\\n\\n return trip_path\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6825437","0.6825437","0.6509935","0.5756425","0.5675671","0.5626487","0.55647385","0.5557139","0.554731","0.55453545","0.5439347","0.5434702","0.5434155","0.5415356","0.54112595","0.5397447","0.5393359","0.53482777","0.53389424","0.5324333","0.5324295","0.531536","0.53137255","0.53132844","0.53029615","0.5286152","0.5284784","0.5281468","0.5268572","0.5255322","0.52531725","0.52351743","0.5234341","0.5230322","0.5225164","0.5210386","0.52061355","0.5188119","0.51844525","0.51656246","0.5165068","0.5158089","0.5153654","0.515038","0.514477","0.5140107","0.5138161","0.5134582","0.51341695","0.5126916","0.5125591","0.51224047","0.51162076","0.5113529","0.5109592","0.51094747","0.5101548","0.5100502","0.5099669","0.50973254","0.5096959","0.50890714","0.50880986","0.508772","0.5085088","0.5072943","0.506622","0.50624126","0.50619197","0.50519","0.50481457","0.5038451","0.5032973","0.50247276","0.5019004","0.5008929","0.5006406","0.5001332","0.4999743","0.499528","0.4989616","0.49857676","0.49846405","0.49825162","0.49821806","0.49761212","0.4972746","0.49689382","0.49685726","0.49586573","0.4954167","0.49517095","0.49466228","0.4945592","0.49362132","0.49344233","0.492944","0.49292842","0.49286023","0.4918535"],"string":"[\n \"0.6825437\",\n \"0.6825437\",\n \"0.6509935\",\n \"0.5756425\",\n \"0.5675671\",\n \"0.5626487\",\n \"0.55647385\",\n \"0.5557139\",\n \"0.554731\",\n \"0.55453545\",\n \"0.5439347\",\n \"0.5434702\",\n \"0.5434155\",\n \"0.5415356\",\n \"0.54112595\",\n \"0.5397447\",\n \"0.5393359\",\n \"0.53482777\",\n \"0.53389424\",\n \"0.5324333\",\n \"0.5324295\",\n \"0.531536\",\n \"0.53137255\",\n \"0.53132844\",\n \"0.53029615\",\n \"0.5286152\",\n \"0.5284784\",\n \"0.5281468\",\n \"0.5268572\",\n \"0.5255322\",\n \"0.52531725\",\n \"0.52351743\",\n \"0.5234341\",\n \"0.5230322\",\n \"0.5225164\",\n \"0.5210386\",\n \"0.52061355\",\n \"0.5188119\",\n \"0.51844525\",\n \"0.51656246\",\n \"0.5165068\",\n \"0.5158089\",\n \"0.5153654\",\n \"0.515038\",\n \"0.514477\",\n \"0.5140107\",\n \"0.5138161\",\n \"0.5134582\",\n \"0.51341695\",\n \"0.5126916\",\n \"0.5125591\",\n \"0.51224047\",\n \"0.51162076\",\n \"0.5113529\",\n \"0.5109592\",\n \"0.51094747\",\n \"0.5101548\",\n \"0.5100502\",\n \"0.5099669\",\n \"0.50973254\",\n \"0.5096959\",\n \"0.50890714\",\n \"0.50880986\",\n \"0.508772\",\n \"0.5085088\",\n \"0.5072943\",\n \"0.506622\",\n \"0.50624126\",\n \"0.50619197\",\n \"0.50519\",\n \"0.50481457\",\n \"0.5038451\",\n \"0.5032973\",\n \"0.50247276\",\n \"0.5019004\",\n \"0.5008929\",\n \"0.5006406\",\n \"0.5001332\",\n \"0.4999743\",\n \"0.499528\",\n \"0.4989616\",\n \"0.49857676\",\n \"0.49846405\",\n \"0.49825162\",\n \"0.49821806\",\n \"0.49761212\",\n \"0.4972746\",\n \"0.49689382\",\n \"0.49685726\",\n \"0.49586573\",\n \"0.4954167\",\n \"0.49517095\",\n \"0.49466228\",\n \"0.4945592\",\n \"0.49362132\",\n \"0.49344233\",\n \"0.492944\",\n \"0.49292842\",\n \"0.49286023\",\n \"0.4918535\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6100076"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":24592,"cells":{"query":{"kind":"string","value":"RETURNS A set of outgoing links and corresponding splitting ratios for flow f at node s"},"document":{"kind":"string","value":"def get_paths_for_flow(F, s, f):\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links"},"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 traverse_graph(F, f, s, t, u, sr):\n def get_paths_for_flow(F, s, f):\n \"\"\"\n RETURNS\n A set of outgoing links and corresponding splitting ratios for flow f\n at node s\n \"\"\"\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links\n \n if u == t:\n return [([t], sr)]\n\n outgoing_links = get_paths_for_flow(F, u, f)\n paths_to_t = []\n\n for ((current_node, next_hop), split_ratio) in outgoing_links:\n paths_from_u_to_t = traverse_graph(F, f, s, t, next_hop, split_ratio) \n paths_to_t.extend(paths_from_u_to_t)\n\n paths_to_t_with_u = []\n for path in paths_to_t:\n nodes, sr = path\n new_path = [u] + nodes\n paths_to_t_with_u.append((new_path, sr))\n\n return paths_to_t_with_u","def step(nodes, outputs, edges):\n flowed = []\n for node_name in nodes.copy():\n if node_name in flowed:\n continue\n if len(nodes[node_name]) == 2:\n if node_name in flowed:\n continue\n node = [int(value) for value in nodes[node_name]]\n low_value, high_value = min(node), max(node)\n low_flow, high_flow = edges[node_name] \n low_dictionary, low_node_name = low_flow\n high_dictionary, high_node_name = high_flow\n low_node = low_dictionary.get(low_node_name, tuple())\n high_node = high_dictionary.get(high_node_name, tuple())\n low_dictionary[low_node_name] = low_node + (str(low_value),)\n high_dictionary[high_node_name] = high_node + (str(high_value),)\n nodes[node_name] = tuple()\n if low_dictionary is nodes:\n flowed.append(low_node_name)\n if high_dictionary is nodes:\n flowed.append(high_node_name)\n return nodes, outputs, edges","def split_at_nodes(shp):\n nodes = find_nodes(shp)\n nodeIds = list(nodes)\n nodeIds.sort()\n nodeIds = dict([(node,i) for i,node in enumerate(nodeIds)])\n \n for road in shp:\n vrts = road.vertices\n midVrts = set(road.vertices[1:-1]) #we know end points are nodes\n midNodes = midVrts.intersection(nodes) # find any nodes in the middle of the feature.\n midIdx = [vrts.index(node) for node in midNodes] # Get their indices\n midIdx.sort()\n if midIdx:\n #print vrts\n starts = [0]+midIdx\n stops = [x+1 for x in midIdx]+[None]\n for start,stop in zip(starts,stops):\n feat = pysal.cg.Chain(vrts[start:stop])\n rec = (nodeIds[feat.vertices[0]],nodeIds[feat.vertices[-1]],False)\n yield feat,rec\n else:\n rec = (nodeIds[road.vertices[0]],nodeIds[road.vertices[-1]],False)\n yield road,rec","def _split(self):\r\n \r\n temp = [self.upstream.demand]\r\n for item, p in zip(self.downstream, self.priority):\r\n temp.append(item.supply/p)\r\n \r\n flow = min(temp) # total flow\r\n \r\n self.upstream.outflow = flow\r\n \r\n for item, p in zip(self.downstream, self.priority):\r\n item.inflow = p * flow","def ford_fulkerson_algorithm(graph: np.ndarray, source: int, sink: int) -> np.ndarray:\r\n\r\n residual_graph = copy.deepcopy(graph)\r\n row = len(residual_graph)\r\n parent = [-1] * row\r\n max_flow = 0\r\n\r\n if source == sink or sink < 0 or source < 0 or source >= row or sink >= row:\r\n raise WrongInputException('Wrong input source/sink vertice(s)')\r\n\r\n while bfs(residual_graph, row, source, sink, parent):\r\n\r\n path_flow = float(\"Inf\")\r\n s = sink\r\n while s != source:\r\n path_flow = min(path_flow, residual_graph[parent[s]][s])\r\n s = parent[s]\r\n\r\n max_flow += path_flow\r\n\r\n v = sink\r\n while v != source:\r\n u = parent[v]\r\n residual_graph[u][v] -= path_flow\r\n residual_graph[v][u] += path_flow\r\n v = parent[v]\r\n print(\"Max flow: %d\" % max_flow)\r\n\r\n return residual_graph","def split_edges(self, maximum_distance):\n \"\"\" Iterate through the vertices of each section. For each vertex v, evaluate edges for which v is a source.\n If an edge of weight greater than maximum_distance, then split it. \"\"\"\n for section_id in self.sections:\n utils.print_progress(len(self.sections), prefix='splitting edges')\n current_section = [] # Need to update the section data after splitting the edges.\n for source in self.sections[section_id]:\n current_section.append(source)\n edges_to_remove = [] # If an edge is split, it will need to be removed.\n for edge in self.graph.get_out_edges(source):\n if self.edge_weights[edge] > maximum_distance:\n target = edge[1] # edge is a numpy array of [source, target, edge]. Select target.\n edges_to_remove.append(self.graph.edge(edge[0], edge[\n 1])) # If an edge is split, the original edge should be removed.\n\n new_edge_count = int(math.ceil(self.edge_weights[edge] / maximum_distance))\n new_edge_distance = self.edge_weights[edge] / new_edge_count\n current_point = shapes.Point.from_list(\n list(self.node_locations[source]) + [self.node_heading[target]])\n previous_vertex = source\n for _ in range(new_edge_count):\n current_point = utils.offset_point(current_point, new_edge_distance, current_point.bearing)\n current_vertex = self.graph.add_vertex()\n current_section.append(current_vertex) # The new vertex becomes a part of the section.\n \"\"\" Populate the property map for the new vertex. Inherit values from the target node,\n unless the target node is a junction node. Then inherit values from the source. \"\"\"\n self.node_locations[current_vertex] = current_point.as_list()\n self.node_heading[current_vertex] = current_point.bearing\n property_vertex = source if not self.junctions[target] else target\n self.node_speed_limit[current_vertex] = self.node_speed_limit[property_vertex]\n self.node_width[current_vertex] = self.node_width[property_vertex]\n self.node_id[current_vertex] = self.node_id[property_vertex]\n\n \"\"\" Create an edge between the previous vertex and the newly created vertex, \n and update the edge weight property map. \"\"\"\n current_edge = self.graph.add_edge(previous_vertex, current_vertex)\n self.edge_weights[current_edge] = new_edge_distance\n\n # The current vertex becomes the previous vertex in the next step.\n previous_vertex = current_vertex\n\n \"\"\" Create an edge between the last new vertex that was created and the target of the\n original edge which is being split, and update the property map. \"\"\"\n self.edge_weights[self.graph.add_edge(previous_vertex, target)] = new_edge_distance\n list(map(self.graph.remove_edge, edges_to_remove)) # Remove all relevant edges\n self.sections[section_id] = current_section # Update the section with the new vertices","def dfs(x, p, step):\n disc[x] = low[x] = step\n for xx in graph.get(x, []): \n if disc[xx] == inf: \n step += 1\n dfs(xx, x, step)\n low[x] = min(low[x], low[xx])\n if low[xx] > disc[x]: ans.append([x, xx]) # bridge\n elif xx != p: low[x] = min(low[x], disc[xx])","def get_flow_2frames(self, x):\n b, n, c, h, w = x.size()\n x_1 = x[:, :-1, :, :, :].reshape(-1, c, h, w)\n x_2 = x[:, 1:, :, :, :].reshape(-1, c, h, w)\n flows_backward = self.spynet(x_1, x_2)\n flows_backward = [flow.view(b, n - 1, 2, h // 2 ** i, w // 2 ** i) for flow, i in zip(flows_backward, range(4))]\n flows_forward = self.spynet(x_2, x_1)\n flows_forward = [flow.view(b, n - 1, 2, h // 2 ** i, w // 2 ** i) for flow, i in zip(flows_forward, range(4))]\n return flows_backward, flows_forward","def sg_hops (self):\n return (link for s, d, link in self.network.edges_iter(data=True) if\n link.type == Link.SG)","def compute_greedy_flow_allocations( target_graph\n , flow_selection_fn\n , seed_number=DEFAULT_SEED_NUMBER):\n\n flow_allocation_seed_number = seed_number\n np.random.seed(flow_allocation_seed_number)\n\n link_utilization = {tuple(sorted(link_tuple)): 0.0 for link_tuple in target_graph.edges}\n flows = []\n\n while True:\n capacity_was_exceeded = False\n\n source_node, destination_node = flow_selection_fn(target_graph.nodes)\n flow_tx_rate = np.random.uniform(FLOW_TX_RATE_LOWER_BOUND, FLOW_TX_RATE_UPPER_BOUND)\n\n connecting_paths = list(node_disjoint_paths(target_graph, source_node, destination_node))\n disjoint_path_count = len(connecting_paths)\n flow_rate_per_subpath = flow_tx_rate / disjoint_path_count\n for path in [nx.utils.pairwise(p_i) for p_i in connecting_paths]:\n for u, v in [tuple(sorted(t_i)) for t_i in path]:\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\n capacity_was_exceeded = True\n break\n link_utilization[u, v] += flow_rate_per_subpath\n if capacity_was_exceeded:\n break\n if capacity_was_exceeded:\n break\n\n the_flow = Flow( source_node = source_node\n , destination_node = destination_node\n , flow_tx_rate = flow_tx_rate\n , paths = connecting_paths\n , splitting_ratio = [1.0/disjoint_path_count]*disjoint_path_count\n )\n flows.append(the_flow)\n return flows, link_utilization","def compute_flow(self, lqs):\n n, t, c, h, w = lqs.size()\n lqs_1 = lqs[:, :-1, :, :, :].reshape(-1, c, h, w)\n lqs_2 = lqs[:, 1:, :, :, :].reshape(-1, c, h, w)\n flows_backward = self.spynet(lqs_1, lqs_2).view(n, t - 1, 2, h, w)\n if self.is_mirror_extended:\n flows_forward = None\n else:\n flows_forward = self.spynet(lqs_2, lqs_1).view(n, t - 1, 2, h, w)\n return flows_forward, flows_backward","def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\n demand: float,\n routing: np.ndarray) -> np.ndarray:\n edge_mapping = {edge: i for i, edge in\n enumerate(sorted(self.graph.edges))}\n\n link_utilisation = np.zeros(self.num_edges)\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\n node_flow[flow[0]] = demand\n\n to_explore = [flow[0]]\n while to_explore:\n current_node = to_explore.pop(0)\n current_flow = node_flow[current_node]\n\n # this is the flow destination node so we absorb all flow\n if current_node == flow[1]:\n node_flow[current_node] = 0.0\n continue\n\n # push the flow at this node over all edges\n for edge in self.graph.out_edges(current_node):\n edge_index = edge_mapping[edge]\n ratio = routing[edge_index]\n flow_to_send = ratio * current_flow\n # only send flow if greater than epsilon (so no 'infinite' loops)\n if flow_to_send > 1.e-8:\n node_flow[edge[1]] += ratio * current_flow\n # all important step, update our output\n link_utilisation[edge_index] += ratio * current_flow\n # have updated the dst so add it to the list of things to do\n to_explore.append(edge[1])\n # we've moved all the flow from this node now, so reset back to zero\n node_flow[current_node] = 0.0\n\n return link_utilisation","def DRBFS(self, flow, edge_mark):\n\t\t# Distance flag for each node\n\t\td = {v:float('inf') for v in self.topo.nodes}\n\t\t# Parent node for each node\n\t\tpa = {v:-1 for v in self.topo.nodes}\n\t\t# Request info\n\t\ts = flow[0]\n\t\tt = flow[1]\n\n\t\t# BFS to find a min-hop path\n\t\tqueue = [s]; hdr = 0; d[s] = 0\n\t\twhile hdr < len(queue):\n\t\t\tu = queue[hdr]\n\t\t\thdr += 1\n\n\t\t\tfor v in self.topo.topo.neighbors(u):\n\t\t\t\tif edge_mark[(u, v)] or d[v] <= d[u] + 1:\n\t\t\t\t\tcontinue\n\t\t\t\tqueue.append(v)\n\t\t\t\td[v] = d[u] + 1\n\t\t\t\tpa[v] = u\n\t\t\t\tif v == t:\n\t\t\t\t\t# This is because when BFS on edges, the first time reaching t meaning the smallest hop it can be reached\n\t\t\t\t\thdr = len(queue)\n\t\t\t\t\tbreak\n\n\t\tif d[t] == float('inf'):\n\t\t\treturn False\n\n\t\tp = [t]; v = t\n\t\twhile v != s and v != -1:\n\t\t\tv = pa[v]\n\t\t\tp.append(v)\n\t\tp.reverse()\n\n\t\treturn p","def get_all_sghop_info (nffg, return_paths=False):\n sg_map = {}\n for i in nffg.infras:\n for p in i.ports:\n for fr in p.flowrules:\n # if fr.external:\n # continue\n if fr.id not in sg_map:\n # The path is unordered!!\n path_of_shop = []\n flowclass = NFFGToolBox._extract_flowclass(fr.match.split(\";\"))\n sg_map[fr.id] = [None, None, flowclass, fr.bandwidth, fr.delay]\n # We have to find the BEGINNING of this flowrule sequence.\n inbound_link = NFFGToolBox._find_infra_link(nffg, p, outbound=False,\n accept_dyn=True)\n while inbound_link.type != 'DYNAMIC':\n path_of_shop.append(inbound_link)\n if inbound_link.src.node.type == 'SAP':\n break\n # The link is STATIC, and its src is not SAP so it is an Infra.\n prev_fr, prev_p = \\\n NFFGToolBox._get_flowrule_and_its_starting_port(\n inbound_link.src.node, fr.id)\n NFFGToolBox._check_flow_consistencity(sg_map, prev_fr)\n inbound_link = NFFGToolBox._find_infra_link(nffg, prev_p,\n outbound=False,\n accept_dyn=True)\n # 'inbound_link' is DYNAMIC here or it is STATIC and starts from\n # a SAP,\n # so the sequence starts here\n sg_map[fr.id][0] = inbound_link.src\n\n # We have to find the ENDING of this flowrule sequence.\n output_port = NFFGToolBox._get_output_port_of_flowrule(i, fr)\n if output_port is None:\n continue\n outbound_link = NFFGToolBox._find_infra_link(nffg, output_port,\n outbound=True,\n accept_dyn=True)\n while outbound_link.type != 'DYNAMIC':\n path_of_shop.append(outbound_link)\n if outbound_link.dst.node.type == 'SAP':\n break\n # The link is STATIC and its dst is not a SAP so it is an Infra.\n next_fr, _ = NFFGToolBox._get_flowrule_and_its_starting_port(\n outbound_link.dst.node, fr.id)\n # '_' is 'outbound_link.dst'\n next_output_port = NFFGToolBox._get_output_port_of_flowrule(\n outbound_link.dst.node, next_fr)\n NFFGToolBox._check_flow_consistencity(sg_map, next_fr)\n outbound_link = NFFGToolBox._find_infra_link(nffg,\n next_output_port,\n outbound=True,\n accept_dyn=True)\n # the 'outbound_link' is DYNAMIC here or finishes in a SAP, so the\n # flowrule sequence finished here.\n sg_map[fr.id][1] = outbound_link.dst\n\n if return_paths:\n sg_map[fr.id].append(path_of_shop)\n\n return sg_map","def routes_for_od(self, r, s):\n\n for path in self.paths_for_od(r, s):\n route = self._road_network.network.copy()\n\n for edge in route.edges_iter():\n u,v = edge\n if BaseRouter._edge_in_path(path, edge):\n route.edge[u][v]['pathweight'] = 0.1\n else:\n route.edge[u][v]['pathweight'] = 1.0\n\n # Set node weights\n for node in route:\n try:\n dist_from_path = nx.shortest_path_length(route,\n node,\n path[-1],\n weight='pathweight')\n except nx.NetworkXNoPath:\n dist_from_path = float('inf')\n\n route.node[node]['weight'] = math.exp(-self._beta*dist_from_path)\n\n \n # Create policy from weights\n def edge_weight(u,v):\n return route.node[v]['weight']*math.exp(\n -self._beta*route.edge[u][v]['pathweight'])\n\n for node in route:\n edges = route.edges(node)\n total_edge_weight = reduce(\n lambda x,y: x+y,\n [edge_weight(u,v) for u,v in edges],\n 0.0)\n\n for u,v in edges:\n route[u][v]['weight'] = \\\n edge_weight(u, v) / float(total_edge_weight)\n\n yield Route(route, path)","def dfs_r(self, s):\n g = Graph(attr={DIRECTED: True})\n return self.dfs_rec(g, ('#', s))","def distribute(node, rank_links):\n r = rank_links[0]\n links = rank_links[1]\n\n ol = str(links).split('|')\n Ni = len(ol)\n\n # if the node is for dangling (i.e. no outgoing link),\n # emit the loss to redistribute to all the incoming\n # links to the dangling node\n if (Ni == 1 and ol[0] == '') or Ni == 0:\n yield 'DANGLING', r\n else:\n r_new = float(r)/float(Ni)\n for l in ol:\n yield l, r_new\n\n # recover graph structure\n if links <> '':\n yield node, links","def update_flow(self):\n start_nodes = []\n end_nodes = []\n capacities = []\n # (1): add all edges (u, v) with capacity ub-lb\n B = self.get_max_lb()*(self.num_edges() - len(self) + 2)\n for arc in self.arc_info.keys():\n if self.arc_info[arc][\"upper_bound\"] == float('inf'):\n self.arc_info[arc][\"upper_bound\"] = B\n for arc in self.arc_info.keys():\n start_nodes.append(self.arc_info[arc][\"start\"])\n end_nodes.append(self.arc_info[arc][\"destin\"])\n capacities.append(int(self.arc_info[arc][\"upper_bound\"]\\\n - self.arc_info[arc][\"lower_bound\"]))\n # (2): add edge (t, s) with capacity B\n # B = max_lb * (m - n + 2)\n B = self.get_max_lb()*(self.num_edges() - len(self) + 2)\n if B == 0:\n #B = float('inf')\n B = 100000\n start_nodes.append(self.sink())\n end_nodes.append(self.source())\n capacities.append(int(B))\n # (3): for all verts, if exc > 0, add edge (s', v) with capacity exc(v),\n # and if exc < 0, add edge(s', v) with capacity -exc(v)\n s_prime = max(self.vertices) + 1\n t_prime = max(self.vertices) + 2\n print(\"s'={}, t'={}\".format(s_prime, t_prime))\n for v in self:\n #print(\"vert {} in arcs: {}\".format(v,\n # self.in_arcs_lists[v]))\n # compute exc: lower bounds of in - lower bounds of out\n sum_lb_in = 0\n for in_arc in self.in_arcs_lists[v]:\n sum_lb_in += self.arc_info[in_arc][\"lower_bound\"]\n sum_lb_out = 0\n #print(\"vert {} out arcs: {}\".format(v,\n # self.out_arcs_lists[v]))\n for out_arc in self.out_arcs_lists[v]:\n sum_lb_out += self.arc_info[out_arc][\"lower_bound\"]\n exc = sum_lb_in - sum_lb_out\n #print(\"exc is {}\".format(exc))\n if exc > 0:\n start_nodes.append(s_prime)\n end_nodes.append(v)\n capacities.append(int(exc))\n else:\n start_nodes.append(v)\n end_nodes.append(t_prime)\n capacities.append(int(-exc))\n # solve maxflow\n #print(\"s' is {} and t' is {}\".format(s_prime, t_prime))\n max_flow = pywrapgraph.SimpleMaxFlow()\n for u, v, cap in zip(start_nodes, end_nodes, capacities):\n #print(\"Adding edge {}, {} with cap {}\".format(u,v,cap))\n max_flow.AddArcWithCapacity(u, v, cap)\n success = True\n if max_flow.Solve(s_prime, t_prime) == max_flow.OPTIMAL:\n #print('Max flow: {}'.format( max_flow.OptimalFlow()))\n #print(' Arc Flow / Capacity')\n for i in range(max_flow.NumArcs()):\n # print('%1s -> %1s %3s / %3s' % (\n # max_flow.Tail(i),\n # max_flow.Head(i),\n # max_flow.Flow(i),\n # max_flow.Capacity(i)))\n # check that (s', v) edges are saturated (once we find a false,\n # stay false forever)\n if success:\n if max_flow.Tail(i) == s_prime:\n success = max_flow.Flow(i) == max_flow.Capacity(i)\n else:\n success = False\n print('There was an issue with the max flow input.')\n if success:\n # update the flows to be the flow found from maxflow problem\n for i in range(max_flow.NumArcs()):\n # if this is an original arc, update the flow\n if max_flow.Tail(i) != s_prime \\\n and max_flow.Head(i) != t_prime \\\n and not (max_flow.Tail(i) == self.sink() \\\n and max_flow.Head(i) == self.source()):\n # update arc\n start = max_flow.Tail(i)\n destin = max_flow.Head(i)\n arc = self.get_arc(start, destin)\n new_flow = self.arc_info[arc][\"lower_bound\"] + max_flow.Flow(i)\n old_flow = self.arc_info[arc][\"weight\"]\n self.arc_info[arc][\"weight\"] = new_flow\n #print(\"Edge {} {} adjusted from {} to {}\".format(\n # start,\n # destin,\n # old_flow,\n # new_flow\n # ))\n self.check_conservation_of_flow() # check that solution is valid\n return True\n else:\n return False","def findPathsToBase(A,bSize):\n M,N = A.shape\n pressedPaths = []\n\n #For every two nodes in the base find all paths between them\n for b1 in range(bSize):\n for b2 in range(bSize):\n #Remove all other base nodes from the graph so that\n #we only find paths that go through the specialization set\n if b1 == b2:\n #In this case we are looking for a cycle.\n mask = [b1]+list(range(bSize,N))\n newSize = len(mask) + 1\n reduA = np.zeros((newSize,newSize))\n #Because the networkx cycle finders don't do what we need\n #them to do, we create a new graph and find paths instead\n reduA[:-1,:-1] = A[mask,:][:,mask]\n #Remove ingoing edges from the base node and add to new node\n reduA[-1,:] = reduA[0,:]\n reduA[0,:] = np.zeros(newSize)\n G = nx.DiGraph(reduA.T)\n #Find paths from the base node to the new node\n #same as finding all the cycles\n paths = list(nx.all_simple_paths(G,0,newSize-1))\n\n else:\n mask = [b1,b2]+list(range(bSize,N))\n reduA = A[mask,:][:,mask]\n #Remove base node interactions\n reduA[:2,:2] = np.zeros((2,2))\n G = nx.DiGraph(reduA.T)\n paths = list(nx.all_simple_paths(G,0,1))\n\n #Process Paths so that they make sense when the rest of the base\n #set is added to the graph\n for p in paths:\n if p != []:\n if b1 == b2:\n p = np.array(p) + bSize-1\n else:\n p = np.array(p) + bSize-2\n p[[0,-1]] = [b1, b2]\n pressedPaths.append(p)\n\n return pressedPaths","def compute_half_life_vested_shares(params, step, sL, s, inputs):\n key = 'delegators'\n \n delegators = s['delegators']\n\n half_life_vesting_rate = params['half_life_vesting_rate']\n \n for delegator in delegators.values():\n # for future computation speed, vest them in chunks, it doesn't matter which chunk\n shares_vesting_this_period = delegator.unvested_shares * half_life_vesting_rate\n for timestep in delegator._unvested_shares:\n remaining_shares_to_vest = shares_vesting_this_period\n if delegator._unvested_shares[timestep] > remaining_shares_to_vest:\n delegator._unvested_shares[timestep] -= remaining_shares_to_vest\n break\n else:\n # 0 out and go onto the next one\n remaining_shares_to_vest -= delegator._unvested_shares[timestep]\n delegator._unvested_shares[timestep] = 0\n \n delegator.vested_shares += shares_vesting_this_period\n # print(f'{delegator.vested_shares=}, {delegator.unvested_shares=}, {delegator.shares=}')\n value = delegators\n\n return key, value","def dfs_traversal(graph, s, goals=[]):\n visited = []\n boundary = [s]\n while len(boundary) > 0:\n v = boundary.pop()\n visited += [v]\n if v in goals:\n return visited\n for w in neighbours(v, graph):\n if w not in visited and w not in boundary:\n boundary.append(w)\n return visited\n\n \"\"\"\n visited = []\n boundary = [s]\n while len(boundary) > 0:\n v = boundary.pop()\n visited += [v]\n for w in neighbours(v, graph):\n if w not in visited and w not in boundary:\n boundary.append(w)\n if w in goals:\n v = boundary.pop()\n visited += [v]\n return visited\n\"\"\"","def get_dfs(self, s):\n results = []\n # mark all the vertices as not visited\n visited = [False] * (len(self.graph))\n self._dfs_recursive(s, visited, results)\n return results","def bfs(g: nx.Graph, start_node: Hashable) -> List[Hashable]:\n list_ = list(g.neighbors(start_node))\n len_graph = g.number_of_nodes()\n list2 = [start_node]\n while len(list2) < len_graph:\n for i in range(len(list_) - 1):\n if list_[0] not in list2:\n list2.append(list_[0])\n list_ += list(g.neighbors(list_[0]))\n list_.remove(list_[0])\n # nx.draw(g, with_labels=True)\n # plt.show()\n return list2","def flowingFrom(self, fount):","def hmn2(a, s, m0):\n n = 2*m0**s\n links = np.zeros((int(a/m0*n*sum([1/2**x for x in range(1, s+1)])), 2), dtype=np.int32)\n links_i = 0\n p = 0\n \n # At each hierarchy level a number of a links are established,\n # repeating the process if links are repeated.\n for si in range(1, s+1):\n m0_si = m0**si\n for n in range(0, n+1-2*m0_si, 2*m0_si):\n \n if a == 1:\n i = np.random.randint(0 + n, m0_si + n)\n j = np.random.randint(m0_si + n, 2*m0_si + n)\n links[p] = np.array([i, j])\n p += 1\n \n else:\n while len(np.unique(links[links_i:a + links_i], axis=0)) != a:\n for m in range(a):\n i = np.random.randint(0 + n, m0_si + n)\n j = np.random.randint(m0_si + n, 2*m0_si + n)\n links[links_i:a + links_i][m] = np.array([i, j])\n links_i += a\n \n blocks = np.arange(n).reshape((int(n/m0), m0))\n return np.concatenate((blocks, links))","def destination_floors(self):\r\n return self.destinations","def compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\n logger.debug(f\"comparing {node1},{node2}, traversed {traversed}\")\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\n #remove dummies\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\n #remove dummies\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\n logger.debug(f\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\")\n logger.debug(f\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\")\n if not nbrs1 or not nbrs2:\n if compare_two_nodes(G, node1, node2, ports_weight):\n match_pair[node1] = node2\n logger.debug(f\"no new neihbours, returning recursion {match_pair}\")\n return\n elif len(nbrs1)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n logger.debug(f\"skipping high fanout nets due to large computation, {node1} {nbrs1}\")\n traversed.append(node1)\n return\n elif len(nbrs2)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n traversed.append(node2)\n logger.debug(f\"skipping high fanout nets due to large computation, {node2} {nbrs2}\")\n return\n\n if node1 == node2:\n if node1 in match_pair.keys() or node1 in match_pair.values():\n logger.debug(\"avoid existing pair wise symmetry\")\n return\n logger.debug(f\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\")\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\n ## TBD: filter based on primitive constraints\n ## Right now will try to figure out S/D paths\n if len(SD_nbrs) ==0:\n logger.debug(f\"No SD paths found to traverse\")\n match_pair[node1]=node1\n elif len(SD_nbrs) ==1:\n logger.debug(f\"traversing single S/D path {SD_nbrs}\")\n match_pair[node1]=node1\n traversed.append(node1)\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\n else:\n logger.debug(f\" multiple nodes diverging {SD_nbrs}\")\n logger.debug(f\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\")\n match_pair[node1]=node1\n traversed.append(node1)\n new_sp=sorted(set(SD_nbrs)-set(traversed))\n all_match_pairs_local={}\n for nbr1,nbr2 in combinations(new_sp, 2):\n logger.debug(f\"recursive pair call from single branch {nbr1} {nbr2}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n if new_pair:\n #new_pair[nbr1]=nbr2\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\n if len(all_match_pairs_local)==1:\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\n logger.debug(f\"found inline pair: {pprint.pformat(match_pair, indent=4)}\")\n else:\n for nbr1 in new_sp:\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\n logger.debug(f\"recursive single branch call from single branch {nbr1} {nbr1}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif nbrs1 == nbrs2:\n logger.debug(f\"traversing converging branch\")\n match_pair[node1]=node2\n traversed+=[node1,node2]\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\n logger.debug(f\"all non traversed neighbours: {nbrs1}\")\n if len(nbrs1)==1:\n nbr1=nbr2=nbrs1[0]\n logger.debug(f\"keeping single converged branch inline {nbr1} {nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n else:\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\n logger.debug(f\"recursive call from converged branch {nbr1} {nbr2}\")\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif compare_two_nodes(G,node1,node2,ports_weight):\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\n match_pair[node1]=node2\n traversed+=[node1,node2]\n logger.debug(f\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\")\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\n if len(nbrs1)==0 or len(nbrs2)==0:\n logger.debug(f\"no new SD neihbours, returning recursion {match_pair}\")\n elif len(nbrs1) ==1 and len(nbrs2)==1:\n logger.debug(f\"traversing binary branch\")\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\n elif unique_match:\n logger.debug(f'traversing unique matches {unique_match}')\n match_pair[node1]=node2\n traversed+=[node1,node2]\n for nbr1,nbr2 in unique_match.items():\n logger.debug(f\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\n logger.debug(f\"setting new start points {node1} {node2}\")\n match_pair[node1]=node2\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n else:\n match_pair = {}\n logger.debug(f\"end all traversal from binary branch {node1} {node2}\")\n\n else:\n match_pair = {}\n logger.debug(f\"end of recursion branch, matches {match_pair}\")","def enumerate_links_around_node(self, node):\n\n l0 = self.node_link[node]\n l = l0\n edges = []\n traversing = True\n while traversing:\n edges.append(l)\n v = l[0]\n if v == node:\n l = self.pred_right[l]\n else:\n l = self.pred_left[l]\n if l0 == l:\n traversing = False\n if l0[1] == l[0] and l0[0] == l[1]:\n traversing = False\n #print v, l\n #raw_input('here')\n return edges","def directed_dfs(digraph, start, end, max_total_dist, max_dist_outdoors):\n\n\n path = [[],0 , 0]\n best_path = get_best_path(digraph, start, end, path, max_dist_outdoors, max_total_dist, best_path = None)\n\n if best_path[0] is None:\n raise ValueError('No work')\n else :\n return best_path[0]","def conversion(data_path, nodes, simtime, resolution=1):\r\n\r\n receivers = set() # i.e. neurons; senders can be external inputs\r\n edges_set = set()\r\n\r\n # Ask number of neurons per node\r\n nodes_dict = dict()\r\n if input(\"Every node has same number of neurons? (y/n)\") == \"y\":\r\n n = int(input(\"Number of neurons per node: \"))\r\n for node in range(nodes):\r\n nodes_dict[node] = n\r\n receivers.update([str(node) + \"-\" + str(neuron) for neuron in range(nodes_dict[node])])\r\n else:\r\n for node in range(nodes):\r\n nodes_dict[node] = int(input(\"Number of neurons in node %s: \" % node))\r\n receivers.update([str(node) + \"-\" + str(neuron) for neuron in range(nodes_dict[node])])\r\n\r\n receivers = sorted(list(receivers))\r\n\r\n # Load a part of FNS data to gather information about edges\r\n df = pd.read_csv(data_path, header=None, usecols=[0, 1, 2, 3, 4, 5], chunksize=500000, nrows=2000000)\r\n for chunk in df:\r\n chunk.columns = [\"Burning Time\", \"Firing Node\", \"Firing Neuron\", \"Burning Node\", \"Burning Neuron\",\r\n \"External Source\"]\r\n print(chunk.index)\r\n for node in range(nodes):\r\n temp = chunk.loc[\r\n (chunk[\"Burning Node\"] == node) & (chunk[\"External Source\"] == False)] # Remove external inputs\r\n for i in range(len(temp)):\r\n print(\"Gathering edge information for node: %i/%i. Connection: %i/%i\" % (\r\n node + 1, nodes, i + 1, len(temp)), end=\"\\r\")\r\n sender = str(np.asarray(temp[\"Firing Node\"])[i]) + \"-\" + str(np.asarray(temp[\"Firing Neuron\"])[i])\r\n receiver = str(node) + \"-\" + str(np.asarray(temp[\"Burning Neuron\"])[i])\r\n edges_set.add((sender, receiver))\r\n print(\"Gathering edge information for node: %i/%i. Connection: %i/%i\" % (node + 1, nodes, i + 1, len(temp)))\r\n\r\n status_table = pd.DataFrame(np.zeros((len(receivers), len(range((simtime - 1) * resolution)))),\r\n columns=list(range((simtime - 1) * resolution)), index=receivers)\r\n\r\n df = pd.read_csv(data_path, header=None, usecols=[0, 1, 2, 3, 4, 5], chunksize=1000000)\r\n for chunk in df:\r\n chunk.columns = [\"Burning Time\", \"Firing Node\", \"Firing Neuron\", \"Burning Node\", \"Burning Neuron\",\r\n \"External Source\"]\r\n print(chunk.index)\r\n\r\n # Loop over times instead of receivers: slightly better efficiency for large datasets\r\n times_raw = sorted(set(chunk[\"Burning Time\"]))\r\n status_table_temp = pd.DataFrame(columns=receivers)\r\n status_table_aux = pd.DataFrame(np.zeros((len(receivers), len(range((simtime - 1) * resolution)))),\r\n columns=list(range((simtime - 1) * resolution)), index=receivers)\r\n\r\n times = list(np.arange(0, int(max(times_raw) + 1), 1 / resolution))\r\n min_t = int(np.trunc(min(chunk[\"Burning Time\"])))\r\n max_t = int(np.trunc(max(chunk[\"Burning Time\"])))\r\n\r\n for t in times[min_t:max_t]:\r\n print(\"Gathering nodes' activity dynamics - t: %i/%i\" % (t + 1, max_t), end=\"\\r\")\r\n temp = chunk.loc[np.trunc(chunk[\"Burning Time\"]) == t, (\"Burning Node\", \"Burning Neuron\")]\r\n # Count burning events for each neuron at time t\r\n count = Counter([str(node) + \"-\" + str(neuron) for node, neuron in np.asarray(temp)])\r\n # Every time step we add a Counter dict to fill status table\r\n status_table_temp = status_table_temp.append(count, ignore_index=True)\r\n print(\"Gathering nodes' activity dynamics - t: %i/%i\" % (t + 1, max_t))\r\n\r\n # status_table_temp contains just a limited space of time each chunk\r\n status_table_temp = status_table_temp.transpose()\r\n status_table_temp.columns = list(\r\n np.arange(start=int(np.trunc(min(chunk[\"Burning Time\"]))), stop=int(np.trunc(max(chunk[\"Burning Time\"])))))\r\n status_table_temp = status_table_temp.fillna(0)\r\n\r\n # status_table_aux contains all time steps with temp table values and 0s for the rest each chunk\r\n status_table_aux = status_table_aux.add(status_table_temp)\r\n status_table_aux = status_table_aux.fillna(0)\r\n\r\n # status_table merges all chunks' data\r\n status_table = status_table.add(status_table_aux)\r\n status_table = status_table.fillna(0)\r\n\r\n timestamp = datetime.now()\r\n new_dir = \"gephiFiles\" + timestamp.strftime(\"d%d_%m_%Y-t%H_%M_%S\")\r\n os.mkdir(new_dir)\r\n\r\n # Generate gephi compliant files\r\n t = \"<\" + str(times) + \">\"\r\n gephi_nodes = pd.DataFrame(columns=[\"id\", \"label\", \"timeset\", \"events\", \"node\"])\r\n for idx, node in enumerate(receivers):\r\n print(\"Writing nodes' file for Gephi: %i/%i\" % (idx, len(receivers)), end=\"\\r\")\r\n events_row = [[float(i), int(events)] for i, events in enumerate(status_table.loc[node])]\r\n events_row = str(events_row).replace(\"[[\", \"<[\").replace(\"]]\", \"]>\").replace(\"],\", \"];\")\r\n new_row = pd.Series([node, node, t, events_row, node.split(\"-\")[0]], index=gephi_nodes.columns)\r\n gephi_nodes = gephi_nodes.append(new_row, ignore_index=True)\r\n print(\"Writing nodes' file for Gephi: %i/%i\" % (idx, len(receivers)))\r\n gephi_nodes.to_csv(new_dir + \"/gephi_nodes.csv\", index=False)\r\n\r\n print(\"Compute gephi files with %i edges will last %0.2fm approx.\" % (len(edges_set), len(edges_set) / 12000))\r\n if input(\"Do you want to proceed? (y/n) \") == \"n\":\r\n exit()\r\n gephi_edges = pd.DataFrame(columns=[\"Source\", \"Target\", \"type\", \"id\", \"weight\"])\r\n for idx, edge in enumerate(edges_set):\r\n print(\"Writing edges' file for Gephi: %i/%i\" % (idx, len(edges_set)), end=\"\\r\")\r\n edge_row = pd.Series([edge[0], edge[1], \"Directed\", idx, 1], index=gephi_edges.columns)\r\n gephi_edges = gephi_edges.append(edge_row, ignore_index=True)\r\n print(\"Writing edges' file for Gephi: %i/%i\" % (idx, len(edges_set)))\r\n gephi_edges.to_csv(new_dir + \"/gephi_edges.csv\", index=False)\r\n\r\n return None","def ssf(n, N_max = 6, E_max = 4, time_total = 100 ):\n\n G = nx.DiGraph()\n G.add_edge( 0, 1, time_stamp = 1)\n\n # List of existing nodes, with nodes repeated once for each adjacent edge\n repeated_nodes = [0, 1]\n\n # compute discrete bins for nodes \n DistNodes = _get_distribution( N_max, 0 )\n # compute discrete bins for edges\n DistLinks = _get_distribution( E_max, 1 )\n \n # Start adding the other n - 2 nodes.\n N_current = time_current = 2\n while N_current < n and time_current < time_total + 1:\n # preferential attachment\n N_current = _preferential_attachment( DistNodes, DistLinks, N_current,\n time_total, time_current, n, repeated_nodes, G )\n time_current += 1\n \n# print(time_current, N_current)\n return G","def calc_overall_link_utilisation(self, demands: Demand,\n routing: Routing) -> np.ndarray:\n flows = [(i, j) for i in range(self.num_nodes)\n for j in range(self.num_nodes)\n if i != j]\n\n link_utilisation = np.zeros(self.num_edges)\n\n for i, flow in enumerate(flows):\n flow_link_utilisation = self.calc_per_flow_link_utilisation(flow,\n demands[\n i],\n routing[\n i])\n link_utilisation += flow_link_utilisation\n\n return link_utilisation","def hmn1(a, p, s, m0):\n n = 2*m0**s\n links = np.zeros((2*int(a/m0*n*sum([1/2**x for x in range(1, s+1)])), 2), dtype=np.int32)\n\n links_i = 0\n for si in range(1, s+1):\n # 2 Blocks at the same level get linked with\n # a shrinking probability with rising level.\n m0_si = m0**si\n for n in range(0, n+1-2*m0_si, 2*m0_si):\n # Connection ensures that at the end of each\n # linking process, at least one link between\n # blocks at the same level exists.\n m0_si_n = m0_si + n\n connection = 0\n while connection == 0:\n for link1 in range(n, m0_si_n):\n for link2 in range(m0_si_n, 2*m0_si+n): \n if np.random.rand() < a*p**si:\n links[links_i] = [link1, link2]\n links_i += 1\n connection = 1\n \n # Creates the links in the blocks and removes empty\n # placeholders in links.\n blocks = np.arange(n).reshape((int(n/m0), m0))\n links = np.trim_zeros(links.ravel(), 'b').reshape((links_i, 2))\n\n return np.concatenate((blocks, links))","def get_flows(self, x):\n if self.pa_frames == 2:\n flows_backward, flows_forward = self.get_flow_2frames(x)\n elif self.pa_frames == 4:\n flows_backward_2frames, flows_forward_2frames = self.get_flow_2frames(x)\n flows_backward_4frames, flows_forward_4frames = self.get_flow_4frames(flows_forward_2frames, flows_backward_2frames)\n flows_backward = flows_backward_2frames + flows_backward_4frames\n flows_forward = flows_forward_2frames + flows_forward_4frames\n elif self.pa_frames == 6:\n flows_backward_2frames, flows_forward_2frames = self.get_flow_2frames(x)\n flows_backward_4frames, flows_forward_4frames = self.get_flow_4frames(flows_forward_2frames, flows_backward_2frames)\n flows_backward_6frames, flows_forward_6frames = self.get_flow_6frames(flows_forward_2frames, flows_backward_2frames, flows_forward_4frames, flows_backward_4frames)\n flows_backward = flows_backward_2frames + flows_backward_4frames + flows_backward_6frames\n flows_forward = flows_forward_2frames + flows_forward_4frames + flows_forward_6frames\n return flows_backward, flows_forward","def BellmanFord(t):\n\n\td = [float('inf') for i in nodes]\t# Shortest distance to t\n\tn = [-1 for i in nodes]\t\t\t# Next hop toward t\n\td[t] = 0\n\tfor i in range(len(nodes)-1):\n\t\tfor j,(u,v) in enumerate(links):\n\t\t\tif d[u] > d[v] + length[j]:\n\t\t\t\td[u] = d[v] + length[j] \n\t\t\t\tn[u] = v\n\treturn n,d","def separate_simulations(ns, ps, rs, savename, verbose=True):\n #TODO: find bug that occasionally does not find the shortest path\n if verbose:\n\n for n, p, r in zip(ns, ps, rs):\n \n print('n-{}, p-{}, r-{}'.format(n, p, r))\n \n rand_points = np.random.uniform(size=(2, n-2))\n edge_points = np.array([[0.0, 1.0],[0.0, 1.0]])\n points = np.concatenate((rand_points, edge_points), axis=1)\n \n print('Generated points.', end = '')\n \n connections = get_connections(points, pval=p, radius=r)\n\n print('Got connections.')\n \n print('Getting paths.', end = '...')\n \n print('Longest.', end = '...')\n long_pathBool, long_lengthBool = longest_path(connections.astype(bool))\n long_path, long_length = longest_path(connections)\n\n print('Shortest.', end = '...')\n short_pathBool, short_lengthBool = shortest_path(connections.astype(bool))\n short_path, short_length = shortest_path(connections)\n\n short_pathBoolpoints, long_pathBoolpoints, short_pathpoints, long_pathpoints = [[list(points[:, u]) for u in indexes] for indexes in [short_pathBool, long_pathBool, short_path, long_path]]\n\n print('Saving file -> ' + savename)\n file1 = open(savename,\"a\") \n\n file1.writelines('{} - {} - {} - {} - {} - {} - {} - {} - {} - {} - {}\\n'.format(p, r, n, short_lengthBool, long_lengthBool, short_length, long_length, short_pathBoolpoints, long_pathBoolpoints, short_pathpoints, long_pathpoints))\n file1.close()\n \n else:\n\n for n, p, s in zip(ns, ps, rs):\n\n rand_points = np.random.uniform(size=(2, n-2))\n edge_points = np.array([[0.0, 1.0],[0.0, 1.0]])\n points = np.concatenate((rand_points, edge_points), axis=1)\n\n connections = get_connections(points, pval=p, radius=r)\n\n long_pathBool, long_lengthBool = longest_path(connections.astype(bool))\n long_path, long_length = longest_path(connections)\n\n short_pathBool, short_lengthBool = shortest_path(connections.astype(bool))\n short_path, short_length = shortest_path(connections)\n\n short_pathBoolpoints, long_pathBoolpoints, short_pathpoints, long_pathpoints = [[list(points[:, u]) for u in indexes] for indexes in [short_pathBool, long_pathBool, short_path, long_path]]\n\n file1 = open(savename,\"a\") \n\n file1.writelines('{} - {} - {} - {} - {} - {} - {} - {} - {} - {} - {}\\n'.format(p, r, n, short_lengthBool, long_lengthBool, short_length, long_length, short_pathBoolpoints, long_pathBoolpoints, short_pathpoints, long_pathpoints))\n file1.close()\n \n return True","def get_bipartition(g):\n # Write your code here.\n colorArr = [-1] * (len(g.nodes()) + 1)\n for node in g.nodes():\n start = g.neighbors(node)\n if len(start)>0:\n src = start.pop()\n break\n colorArr[src] = 1\n queue = []\n queue.append(src)\n while (queue):\n u = queue.pop()\n for v in g.nodes():\n if g.has_edge(u, v) and colorArr[v] == -1:\n colorArr[v] = 1 - colorArr[u]\n queue.append(v)\n elif g.has_edge(u, v) and colorArr[u] == colorArr[v]:\n return None\n\n red = set()\n for i in range(1, len(colorArr)):\n if colorArr[i] == 1:\n red.add(i)\n return list(red)\n\n\n\n # Hint! If you'd like to test out these commands without\n # writing a full-fledged program, you might want to familiarise\n # yourself with the Python interactive shell or IPython (available\n # on at least some Aalto IT computers)\n\n # Create a simple line graph g: \"(1)->(2)->(3)\"\n # (The creation parameter is a dict of {node: list_of_neighbors},\n # but this is not something you will be needing in your code.)\n # >>> from networkx import Graph \n # >>> g = Graph({1: [2], 2: [3]})\n # >>> g.number_of_nodes()\n # 3\n\n # Example. Iterate over the nodes and mark them as visited\n # >>> visited = set()\n # >>> for node in g.nodes_iter(): # There is also g.nodes(), which returns a list\n # ... # do some work here\n # ... visited.add(node)\n \n # Example. Given a Node v, get all nodes s.t. there is an edge between\n # v and that node\n # >>> g.neighbors(1)\n # [2]\n\n # Example. Get the edges of the graph:\n # >>> e.edges() # as with nodes, there is also g.edges_iter()\n # [(1, 2), (2, 3)]\n\n # For more information, consult the NetworkX documentation:\n # https://networkx.github.io/documentation/networkx-1.10/tutorial/tutorial.html","def get_path(self, sim, app_name, message, topology_src, alloc_DES, alloc_module, traffic, from_des):\n node_src = topology_src\n DES_dst = alloc_module[app_name][message.dst] # returns an array with all DES process serving\n\n if message.dst not in self.rr.keys():\n self.rr[message.dst] = 0\n\n # print (\"GET PATH\")\n # print (\"\\tNode _ src (id_topology): %i\" % node_src)\n # print (\"\\tRequest service: %s \" % (message.dst))\n # print (\"\\tProcess serving that service: %s (pos ID: %i)\" % (DES_dst, self.rr[message.dst]))\n\n bestPath = []\n bestDES = []\n\n for ix, des in enumerate(DES_dst):\n if message.name == \"RawVideo\" or message.name == \"IdentifyObject\":\n if self.rr[message.dst] == ix:\n dst_node = alloc_DES[des]\n\n path = list(nx.shortest_path(sim.topology.G, source=node_src, target=dst_node, weight='BW'))\n\n bestPath = [path]\n bestDES = [des]\n\n self.rr[message.dst] = (self.rr[message.dst] + 1) % len(DES_dst)\n break\n else: # message.name == \"M.B\"\n\n dst_node = alloc_DES[des]\n\n path = list(nx.shortest_path(sim.topology.G, source=node_src, target=dst_node, weight='BW'))\n if message.broadcasting:\n bestPath.append(path)\n bestDES.append(des)\n else:\n bestPath = [path]\n bestDES = [des]\n\n return bestPath, bestDES","def find_all_feedback_from_FVS(lt_links, ls_FVS=None):\n if not ls_FVS:\n set_nodes = set([])\n for t_link in lt_links:\n set_nodes.add(t_link[0])\n set_nodes.add(t_link[1])\n ls_FVS = FVS_analysis.FVS_finding(list(set_nodes), lt_links)[0]\n #if FVS nodes are already gained, pass this step\n \n llt_feedbacks = []\n dic_ts_FVSnodepair_llt_downstreams = {}#{(FVS node1, FVS node2):list of lt_downstream which starts at FVS node1 and ends at FVS node2}\n for s_FVSnode in ls_FVS:\n llt_downstreams = find_all_downstream_from_seed(lt_links, s_FVSnode, ls_FVS)\n for lt_downstream in llt_downstreams:\n ts_FVSpair = (s_FVSnode, lt_downstream[-1][-1])\n dic_ts_FVSnodepair_llt_downstreams.setdefault(ts_FVSpair,[]).append(lt_downstream)\n \n lts_cyclesofFVS = get_all_cycles(ls_FVS)\n for ts_cycleofFVS in lts_cyclesofFVS:\n if len(ts_cycleofFVS) == 1:\n llt_feedbacks.extend(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[0],ts_cycleofFVS[0])])\n else:\n b_stopflag = False\n lllt_feedbackfragment = []\n for i in range(len(ts_cycleofFVS)-1):\n lllt_feedbackfragment.append(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[i], ts_cycleofFVS[i+1])])\n if not dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[i], ts_cycleofFVS[i+1])]:\n b_stopflag = True\n break\n lllt_feedbackfragment.append(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[-1],ts_cycleofFVS[0])])\n if not dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[-1],ts_cycleofFVS[0])]:\n b_stopflag = True\n if b_stopflag:\n continue#if there is no feedback passing by all FVS nodes of that cycle, pass to next cycle\n \n llt_feedbacks_specific_cycle = lllt_feedbackfragment.pop(0)\n while lllt_feedbackfragment:\n llt_fragments_next = lllt_feedbackfragment.pop(0)\n llt_feedbacks_updated = []\n for lt_fragment in llt_feedbacks_specific_cycle:\n for lt_fragment_next in llt_fragments_next:\n ls_route = [t_link[1] for t_link in lt_fragment[:-1]]\n ls_route_next = [t_link[1] for t_link in lt_fragment_next[:-1]]\n if not set(ls_route).intersection(set(ls_route_next)):\n llt_feedbacks_updated.append(lt_fragment+lt_fragment_next)\n llt_feedbacks_specific_cycle = llt_feedbacks_updated\n llt_feedbacks.extend(llt_feedbacks_specific_cycle)\n\n return llt_feedbacks","def test_get_dependencies_subgraph_by_dfs(\n self, source_node, expected_nodes_in, expected_nodes_out\n ):\n graph = nx.DiGraph()\n graph.add_node(\"pack1\")\n graph.add_node(\"pack2\")\n graph.add_node(\"pack3\")\n graph.add_node(\"pack4\")\n graph.add_edge(\"pack1\", \"pack2\")\n graph.add_edge(\"pack2\", \"pack3\")\n dfs_graph = PackDependencies.get_dependencies_subgraph_by_dfs(\n graph, source_node\n )\n for i in expected_nodes_in:\n assert i in dfs_graph.nodes()\n for i in expected_nodes_out:\n assert i not in dfs_graph.nodes()","def find_sharpest_fork_general(Nodes):\n pair_list = []\n Dis = np.array([])\n for n in Nodes:\n if n.parent is not None:\n if n.parent.parent is not None:\n a = n.parent.children\n if(isinstance(a, list)):\n if(len(a)==2):\n n1 = a[0]\n n2 = a[1]\n pair_list.append([n1 , n2])\n dis = LA.norm(a[0].xyz - a[1].xyz,2)\n Dis = np.append(Dis,dis)\n if(len(Dis)!= 0):\n (b,) = np.where(Dis == Dis.min())\n sharpest_pair = pair_list[b[0]]\n distance = Dis.min()\n else:\n sharpest_pair = [0,0]\n distance = 0.\n return sharpest_pair, distance","def get_bfs(self, s):\n # create a queue for BFS\n queue = []\n # mark all the vertices as not visited\n visited = [False] * (len(self.graph))\n # mark the start node as visited and enqueue it\n visited[s] = True\n queue.append(s)\n results = []\n\n while queue:\n # dequeue a vertex from queue and append to results.\n p = queue.pop(0)\n results.append(p)\n # get all adjacent vertices of the dequeued vertex s,\n # and for any unvisited adjacent, mark it visited and enqueue it.\n for v in self.graph[p]:\n if visited[v] is False:\n visited[v] = True\n queue.append(v)\n\n return results","def sinks(self):\n if self.rank < self.midpoint:\n partner = self.midpoint + (self.rank - self.left)\n if partner == self.right:\n partner -= 1\n else:\n partner = self.left + (self.rank - self.midpoint)\n if partner == self.midpoint:\n partner -= 1\n\n return {partner}","def bfs_traversal(graph, s, goals=[]):\n visited = []\n boundary = deque([s])\n while len(boundary) > 0:\n v = boundary.popleft()\n visited += [v]\n if v in goals:\n return visited\n for w in neighbours(v, graph):\n if w not in visited and w not in boundary:\n boundary.append(w)\n return visited\n\n \"\"\"\n visited = []\n boundary = [s]\n while len(boundary) > 0:\n v = boundary.pop(0)\n visited += [v]\n for w in neighbours(v, graph):\n if w not in goals:\n if w not in visited and w not in boundary:\n boundary.append(w)\n else:\n if w not in visited and w not in boundary:\n boundary.append(w)\n v = boundary.pop(0)\n visited += [v]\n break\n return visited\n \"\"\"","def refugia_adj_5_simsplit(params, ns):\n #20 parameters \n nu1a, nu2a, nu3a, nu1b, nu2b, nu3b, m2_12, m2_13, m2_21, m2_23, m2_31, m2_32, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T2, T3 = params\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\n fs = moments.Spectrum(sts)\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2]) \n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\n ## Population function and migration matrix for T2\n nu_T2 = [nu1a, nu2a, nu3a]\n mig2 = numpy.array([[0, m2_12, m2_13],[m2_21, 0, m2_23], [m2_31, m2_32, 0]]) \n fs.integrate(nu_T2, T2, m=mig2)\n ## Population function and migration matrix for T3\n nu_T3 = [nu1b, nu2b, nu3b]\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \n fs.integrate(nu_T3, T3, m=mig3) \n return fs","def dfs_edges_generator(graph, source, reverse=...):\n ...","def bfs_edges_generator(graph, source, reverse=...):\n ...","def bfs_path(graph, s, goals=[]):\n visited = []\n parents = [None]*len(graph)\n boundary = [s]\n while len(boundary) > 0:\n v = boundary.pop(0)\n visited += [v]\n for w in neighbours(v, graph):\n if w not in visited and w not in boundary:\n boundary.append(w)\n parents[w] = v\n #w's parent\n # put w's parent in the partent list\n return get_path(parents, goals[0], goals[1])","def _compute_longest_path_cut(self, src_uid, dst_uid):\n # NOTE: at the time being the reason why it was chosen to include edges\n # that belong to any path to the returned list, is unclear to me.\n to_visit_uids = [dst_uid]\n node_costs = {}\n node_succs = {}\n subgraph_edge_uids = []\n subgraph_node_uids = [src_uid]\n dsp = 0\n\n if (src_uid == dst_uid): # NOTE: deals with single-block graphs\n node = self._nodes[src_uid]\n return node.get_cost(), [src_uid], [], []\n\n # NOTE: the generated block graph might contain dead ends, thus\n # visited_uids must be pre-computed\n visited_uids = copy.deepcopy(self._nodes.keys())\n lvisited_uids = []\n while len(to_visit_uids) > 0:\n cur_uid = to_visit_uids[0]\n cur_node = self._nodes[cur_uid]\n\n if cur_uid in visited_uids:\n visited_uids.remove(cur_uid)\n\n for pred_uid in cur_node.get_predecessors():\n if pred_uid not in to_visit_uids and pred_uid not in lvisited_uids:\n to_visit_uids.append(pred_uid)\n\n to_visit_uids = to_visit_uids[1:]\n lvisited_uids.append(cur_uid)\n\n to_visit_uids = [dst_uid]\n\n # reverse graph exploration\n while 0 < len(to_visit_uids):\n assert(dsp < len(to_visit_uids))\t# dead ends or loops\n\n cur_uid = to_visit_uids[dsp]\n cur_node = self._nodes[cur_uid]\n\n assert(cur_uid != src_uid)\n assert(cur_uid not in visited_uids)\t# loop!\n\n # skip node for which there is still some unexplored successor\n skip_uid = False\n for succ_uid in cur_node.get_successors():\n if not succ_uid in visited_uids:\n skip_uid = True\n\n if skip_uid:\n dsp += 1\n continue\n else:\n dsp = 0\n\n if cur_uid == dst_uid:\n node_costs[cur_uid] = cur_node.get_cost()\n\n for pred_uid in cur_node.get_predecessors():\n pred_node = self._nodes[pred_uid]\n # get edge pred_uid ---> cur_uid\n edge_uid = Edge.get_edge_uid(pred_uid, cur_uid)\n edge = self._edges[edge_uid]\n edge_cost = edge.get_cost()\n if edge_uid not in subgraph_edge_uids:\n subgraph_edge_uids.append(edge_uid)\n\n # update node distance\n pred_node_cost = node_costs[cur_uid] + edge_cost + pred_node.get_cost()\n if pred_uid not in node_costs or pred_node_cost > node_costs[pred_uid]:\n node_costs[pred_uid] = pred_node_cost\n node_succs[pred_uid] = cur_uid\n\n # update to_visit_uids, a node cannot be visited more than once\n if (pred_uid != src_uid) and (pred_uid not in visited_uids) \\\n and (pred_uid not in to_visit_uids):\n to_visit_uids.append(pred_uid)\n\n to_visit_uids.remove(cur_uid)\n visited_uids.append(cur_uid)\n subgraph_node_uids.append(cur_uid)\n\n # construct path from src_node to dst_node\n cur_uid = src_uid\n maxpath_node_uids = [cur_uid]\n while cur_uid != dst_uid:\n cur_uid = node_succs[cur_uid]\n cur_node = self._nodes[cur_uid]\n if cur_uid not in maxpath_node_uids:\n maxpath_node_uids.append(cur_uid)\n else:\n raise Exception(\"invalid input source code graph: loop detected\")\n\n max_cost = node_costs[src_uid]\n return max_cost, maxpath_node_uids, subgraph_node_uids, subgraph_edge_uids","def _compute_paths_among(self, src_uid, dst_uid):\n to_visit_uids = [dst_uid]\n paths = {}\n idx = 0\n dsp = 0\n\n if (src_uid == dst_uid): # NOTE: deals with single-block graphs\n return [src_uid]\n\n # NOTE: the generated block graph might contain dead ends, thus\n # visited_uids must be pre-computed\n visited_uids = copy.deepcopy(self._nodes.keys())\n lvisited_uids = []\n while len(to_visit_uids) > 0:\n cur_uid = to_visit_uids[0]\n cur_node = self._nodes[cur_uid]\n\n if cur_uid in visited_uids:\n visited_uids.remove(cur_uid)\n\n for pred_uid in cur_node.get_predecessors():\n if pred_uid not in to_visit_uids and pred_uid not in lvisited_uids:\n to_visit_uids.append(pred_uid)\n\n to_visit_uids = to_visit_uids[1:]\n lvisited_uids.append(cur_uid)\n\n to_visit_uids = [dst_uid]\n\n while idx < len(to_visit_uids):\n assert(idx + dsp < len(to_visit_uids))\n\n cur_uid = to_visit_uids[idx + dsp]\n cur_node = self._nodes[cur_uid]\n\n assert(cur_uid != src_uid)\n assert(cur_uid not in visited_uids)\n\n # skip node for which there is still some unexplored successor\n skip_uid = False\n for succ_uid in cur_node.get_successors():\n if succ_uid not in visited_uids:\n skip_uid = True\n\n if skip_uid:\n dsp += 1\n continue\n else:\n dsp = 0\n\n if cur_uid == dst_uid:\n paths[cur_uid] = 1\n\n for pred_uid in cur_node.get_predecessors():\n if pred_uid not in paths:\n paths[pred_uid] = paths[cur_uid]\n else:\n paths[pred_uid] += paths[cur_uid]\n\n # a node cannot be visited more than once\n if pred_uid != src_uid and pred_uid not in visited_uids \\\n and pred_uid not in to_visit_uids:\n to_visit_uids.append(pred_uid)\n\n to_visit_uids.remove(cur_uid)\n visited_uids.append(cur_uid)\n\n return paths[src_uid]","def compute_path_hopping_flow_allocations(target_graph, K=3):\n flow_allocation_seed_number = 0xCAFE_BABE\n np.random.seed(flow_allocation_seed_number)\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n link_utilization = {(u, v): 0.0 for u, v in target_graph.edges}\n node_capacity = {u: 0.0 for u in target_graph.nodes}\n flows = []\n while True:\n source_node, destination_node = flow_selection_fn(target_graph.nodes, 2, replace=False)\n print(source_node, destination_node)\n\n shortest_paths = sorted(nx.all_simple_paths(target_graph, source_node, destination_node,\n cutoff=3),\n key=lambda p: len(p))\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\n\n # flow_tx_rate = np.random.uniform() * 10\n flow_tx_rate = 1.0\n # if node_capacity[source_node] + flow_tx_rate > LINK_CAPACITY:\n # break\n node_capacity[source_node] += flow_tx_rate\n capacity_was_exceeded = False \n for path in [nx.utils.pairwise(p_i) for p_i in k_shortest_paths]:\n for u, v in [sorted(h_i) for h_i in path]:\n flow_rate_per_subpath = flow_tx_rate / K\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\n capacity_was_exceeded = True\n break\n link_utilization[u, v] += flow_rate_per_subpath\n if capacity_was_exceeded:\n break\n\n if capacity_was_exceeded:\n break\n\n the_flow = Flow( source_node = source_node\n , destination_node = destination_node\n , flow_tx_rate = flow_tx_rate\n , paths = k_shortest_paths\n , splitting_ratio = [1.0/K]*K\n )\n flows.append(the_flow)\n return flows, link_utilization","def get_skims(G, transfer_penalty=300, delta=0.2):\n # shortest path\n sp = nx.shortest_path(G, weight='total_travel_time')\n # create a dictionary for stop travel impedance values\n # The travel impedance is also decomposed\n # GTC: total generalized travel cost\n # IVT: in-vehicle travel time\n # NONIVT: the remaining part related to transfer and waiting times\n ti = {}\n fields = ['GTC', \"IVT\", \"WT\", \"TRANSFER\", \"NONIVT\"]\n for key in sp.keys():\n ti[key] = {}\n for field in fields:\n ti[key][field] = dict()\n for source in sp.keys():\n for target in sp[source].keys():\n cur_sp = sp[source][target]\n for field in fields:\n ti[source][field][target] = 0\n if not len(cur_sp) == 1:\n # if not the node itself\n for k in range(len(cur_sp) - 1):\n i = cur_sp[k]\n j = cur_sp[k + 1]\n ti[source]['IVT'][target] += G[i][j]['ivt']\n ti[source]['WT'][target] += G[i][j]['wt']\n ti[source]['NONIVT'][target] += G[i][j]['wt']\n ti[source]['NONIVT'][target] += (len(cur_sp) - 2) * transfer_penalty\n ti[source]['TRANSFER'][target] = (len(cur_sp) - 2) * transfer_penalty\n ti[source]['GTC'][target] = ti[source]['IVT'][target] + ti[source]['NONIVT'][target]\n\n skims = DotMap()\n for field in fields:\n skims[field] = pd.DataFrame([ti[i][field] for i in sp.keys()], index=sp.keys())\n\n x_list = list(nx.get_node_attributes(G, 'x').values())\n y_list = list(nx.get_node_attributes(G, 'y').values())\n df = pd.DataFrame({'node_id': list(sp.keys()), 'x': x_list, 'y': y_list})\n df = df.set_index('node_id')\n\n skims['pos'] = df\n return skims","def get_routing_solution(self):\n G = self.base_digraph\n s1 = self.sources[0]\n s2 = self.sources[1]\n t1 = self.destinations[0]\n t2 = self.destinations[1]\n\n try:\n m = Model('routing')\n m.setParam('OutputFlag', False)\n\n # variables,\n # We have one variable per edge per session\n # e is the dict of dict for the variables\n e = {}\n r = {}\n for i in [1,2]:\n e[i] = {}\n r[i] = m.addVar()\n for u,v in G.edges():\n e[i][u,v] = m.addVar(lb=0)\n\n m.update()\n\n obj = quicksum(r.values())\n m.setObjective(obj, GRB.MAXIMIZE)\n\n # constraints\n # 1. conservations of flow at all intermediate nodes\n # 2. capacity constraints for each edge\n\n for u,v in G.edges():\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\n\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\n\n for n in G.nodes():\n if n not in [s1, s2, t1, t2]:\n for i in [1, 2]:\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\n m.addConstr(inflow == outflow)\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n for u, v in G.edges():\n G[u][v]['Routing'] = {}\n G[u][v]['Routing'][1] = e[1][u,v].x\n G[u][v]['Routing'][2] = e[2][u,v].x\n return (m.objVal, r[1].x, r[2].x)\n else:\n # something went wrong...err...\n print \"Something was wrong, no optimal solution obtained\"\n return None, None, None\n\n except GurobiError:\n Print ('Error Report from Gurobi')","def dfs_path(graph, s, goals=[]):\n visited = []\n parents = [None]*(len(graph))\n boundary = [s]\n while len(boundary) > 0:\n v = boundary.pop()\n visited += [v]\n for w in neighbours(v, graph):\n if w not in visited and w not in boundary:\n boundary.append(w)\n parents[w] = v\n return get_path(parents, goals[0], goals[1])","def caculate_network_statistics(self):\n divide_factor_sum = 0 \n for key in self.stars.keys():\n star = self.stars[key]\n if star.nb_num == 0 :\n self.standalone_star_num += 1 \n\n divide_factor = star.nb_num + 2 * (star.spec_num - star.shared_spec_num )/self.ave_starlet_size\n divide_factor_sum += divide_factor\n divide_factor_int = round(divide_factor)\n self.star_divide_factor_dist[divide_factor_int] = self.star_divide_factor_dist.get(divide_factor_int,0) + 1\n if star.spec_num < star.shared_spec_num:\n print(\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\")\n print(\"with star \" + star.id + \" \" + str(star.spec_num) + \"is less than\" + str(star.shared_spec_num))\n if star.spec_num > star.shared_spec_num:\n self.star_lost_spec_num += star.spec_num - star.shared_spec_num\n self.ave_divide_factor_star = divide_factor_sum/self.stars_length\n\n divide_factor_sum = 0 \n for key in self.starlets.keys():\n starlet = self.starlets[key]\n if starlet.nb_num == 0 :\n self.standalone_starlet_num += 1 \n\n divide_factor = starlet.nb_num + 2 * (starlet.spec_num - starlet.shared_spec_num )/self.ave_star_size\n divide_factor_sum += divide_factor\n divide_factor_int = round(divide_factor)\n self.starlet_divide_factor_dist[divide_factor_int] = self.starlet_divide_factor_dist.get(divide_factor_int,0) + 1\n if starlet.spec_num < starlet.shared_spec_num:\n print(\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\")\n print(\"with star \" + starlet.id + \" \" + str(starlet.spec_num) + \"is less than\" + str(starlet.shared_spec_num))\n if starlet.spec_num > starlet.shared_spec_num:\n self.starlet_lost_spec_num += starlet.spec_num - starlet.shared_spec_num\n self.ave_divide_factor_starlet = divide_factor_sum/self.starlets_length","def Sidetrack2Path(tree, sidetracks, s, t):\n\tvisited = set()\t\t# visited nodes\n\tpath = []\t\t# set of edges\n\tsidenodes = set(links[e][0] for e in sidetracks)\t# nodes that needs to be sidetracked\n\tcurrent = s\n\twhile current != t:\n\t\t# Loop detection\n\t\tif current in visited:\n\t\t\treturn []\n\t\telse:\n\t\t\tvisited.add(current)\n\t\t# No loop is found yet, proceed one hop\n\t\tif current in sidenodes:\n\t\t\tedge = [e for e in sidetracks if links[e][0] == current]\n\t\t\tcurrent = links[edge[0]][1]\n\t\t\tpath.append(edge[0])\n\t\telse:\n\t\t\tedge = [i for i,e in enumerate(links) if e == (current,tree[current])]\n\t\t\tcurrent = links[edge[0]][1]\n\t\t\tpath.append(edge[0])\n\t# Destination reached. Return the path\n\treturn path","def test_tree_splay() -> None:\n t = generate_graph_resources(5)\n field(t, (\"dr_1\", \"ds_1\", \"f1\")).references.append(\n (FieldAddress(\"dr_2\", \"ds_2\", \"f1\"), \"to\")\n )\n field(t, (\"dr_1\", \"ds_1\", \"f1\")).references.append(\n (FieldAddress(\"dr_3\", \"ds_3\", \"f1\"), \"to\")\n )\n field(t, (\"dr_1\", \"ds_1\", \"f1\")).references.append(\n (FieldAddress(\"dr_4\", \"ds_4\", \"f1\"), \"to\")\n )\n field(t, (\"dr_1\", \"ds_1\", \"f1\")).references.append(\n (FieldAddress(\"dr_5\", \"ds_5\", \"f1\"), \"to\")\n )\n field(t, (\"dr_1\", \"ds_1\", \"f1\")).identity = \"email\"\n traversal = Traversal(DatasetGraph(*t), {\"email\": \"X\"})\n\n assert incoming_edges(traversal, CollectionAddress(\"dr_1\", \"ds_1\")) == {\n Edge(\n FieldAddress(\"__ROOT__\", \"__ROOT__\", \"email\"),\n FieldAddress(\"dr_1\", \"ds_1\", \"f1\"),\n )\n }\n assert outgoing_edges(traversal, CollectionAddress(\"dr_1\", \"ds_1\")) == {\n Edge(FieldAddress(\"dr_1\", \"ds_1\", \"f1\"), FieldAddress(\"dr_3\", \"ds_3\", \"f1\")),\n Edge(FieldAddress(\"dr_1\", \"ds_1\", \"f1\"), FieldAddress(\"dr_4\", \"ds_4\", \"f1\")),\n Edge(FieldAddress(\"dr_1\", \"ds_1\", \"f1\"), FieldAddress(\"dr_5\", \"ds_5\", \"f1\")),\n Edge(FieldAddress(\"dr_1\", \"ds_1\", \"f1\"), FieldAddress(\"dr_2\", \"ds_2\", \"f1\")),\n }\n\n assert outgoing_edges(traversal, CollectionAddress(\"dr_5\", \"ds_5\")) == set()\n assert incoming_edges(traversal, CollectionAddress(\"dr_2\", \"ds_2\")) == {\n Edge(FieldAddress(\"dr_1\", \"ds_1\", \"f1\"), FieldAddress(\"dr_2\", \"ds_2\", \"f1\"))\n }\n assert incoming_edges(traversal, CollectionAddress(\"dr_3\", \"ds_3\")) == {\n Edge(FieldAddress(\"dr_1\", \"ds_1\", \"f1\"), FieldAddress(\"dr_3\", \"ds_3\", \"f1\"))\n }\n assert incoming_edges(traversal, CollectionAddress(\"dr_4\", \"ds_4\")) == {\n Edge(FieldAddress(\"dr_1\", \"ds_1\", \"f1\"), FieldAddress(\"dr_4\", \"ds_4\", \"f1\"))\n }\n assert incoming_edges(traversal, CollectionAddress(\"dr_5\", \"ds_5\")) == {\n Edge(FieldAddress(\"dr_1\", \"ds_1\", \"f1\"), FieldAddress(\"dr_5\", \"ds_5\", \"f1\"))\n }\n traversal_map, terminators = traversal.traversal_map()\n assert traversal_map == {\n \"__ROOT__:__ROOT__\": {\"from\": {}, \"to\": {\"dr_1:ds_1\": {\"email -> f1\"}}},\n \"dr_1:ds_1\": {\n \"from\": {\"__ROOT__:__ROOT__\": {\"email -> f1\"}},\n \"to\": {\n \"dr_2:ds_2\": {\"f1 -> f1\"},\n \"dr_3:ds_3\": {\"f1 -> f1\"},\n \"dr_4:ds_4\": {\"f1 -> f1\"},\n \"dr_5:ds_5\": {\"f1 -> f1\"},\n },\n },\n \"dr_2:ds_2\": {\"from\": {\"dr_1:ds_1\": {\"f1 -> f1\"}}, \"to\": {}},\n \"dr_3:ds_3\": {\"from\": {\"dr_1:ds_1\": {\"f1 -> f1\"}}, \"to\": {}},\n \"dr_4:ds_4\": {\"from\": {\"dr_1:ds_1\": {\"f1 -> f1\"}}, \"to\": {}},\n \"dr_5:ds_5\": {\"from\": {\"dr_1:ds_1\": {\"f1 -> f1\"}}, \"to\": {}},\n }\n\n assert set(terminators) == {\n CollectionAddress(\"dr_2\", \"ds_2\"),\n CollectionAddress(\"dr_3\", \"ds_3\"),\n CollectionAddress(\"dr_4\", \"ds_4\"),\n CollectionAddress(\"dr_5\", \"ds_5\"),\n }","def get_weight_from_minflow(self):\n start_nodes = []\n end_nodes = []\n capacities = []\n unit_costs = []\n A = 0\n s_prime = self.sink() + 1\n t_prime = self.sink() + 2\n x = self.sink() + 3\n # for every edge in the graph, add edge to mincost flow instance with\n # infinite capacity and cost 1\n # also add backwards edge\n for arc in self.arc_info.keys():\n # forward edge\n start_nodes.append(self.arc_info[arc][\"start\"])\n end_nodes.append(self.arc_info[arc][\"destin\"])\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"start\"],\n self.arc_info[arc][\"destin\"]))\n # backward edge\n start_nodes.append(self.arc_info[arc][\"destin\"])\n end_nodes.append(self.arc_info[arc][\"start\"])\n capacities.append(int(self.arc_info[arc][\"weight\"])) # no negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"destin\"],\n self.arc_info[arc][\"start\"]))\n # add (x,s) and (t,x) edges with same cap, cost as above\n in_weight_x = 0\n for in_arc in self.in_arcs_lists[self.sink()]:\n in_weight_x += self.arc_info[in_arc][\"weight\"]\n out_weight_x = 0\n for out_arc in self.out_arcs_lists[self.source()]:\n out_weight_x += self.arc_info[out_arc][\"weight\"]\n # (x,s)\n start_nodes.append(x)\n end_nodes.append(self.source())\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.source()))\n # backward\n start_nodes.append(self.source())\n end_nodes.append(x)\n capacities.append(int(out_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.source(),\n x))\n # (t,x)\n start_nodes.append(self.sink())\n end_nodes.append(x)\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.sink(),\n x))\n # backward\n start_nodes.append(x)\n end_nodes.append(self.sink())\n capacities.append(int(in_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.sink()))\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\n # and cost 0.\n for v in self:\n # process internal verts only, since we assume source and sink have\n # no in and out edges respectively\n if v != self.source() and v != self.sink():\n # compute a-exc(v)\n in_weight = 0\n for in_arc in self.in_arcs_lists[v]:\n in_weight += self.arc_info[in_arc][\"weight\"]\n out_weight = 0\n for out_arc in self.out_arcs_lists[v]:\n out_weight += self.arc_info[out_arc][\"weight\"]\n a_exc = out_weight - in_weight\n if a_exc < 0:\n # add edge (s', v)\n start_nodes.append(s_prime)\n end_nodes.append(v)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n v,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (v, t')\n start_nodes.append(v)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n v,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # process x node\n a_exc = out_weight_x - in_weight_x\n if a_exc < 0:\n # add edge (s', x)\n start_nodes.append(s_prime)\n end_nodes.append(x)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n x,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (x, t')\n start_nodes.append(x)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n x,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # we must send flow of A from s_prime to t_prime\n supplies = [0]*(len(self) + 3)\n supplies[s_prime] = int(A)\n supplies[t_prime] = int(-A)\n # Instantiate a SimpleMinCostFlow solver.\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\n # Add each arc.\n for i in range(len(start_nodes)):\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\n end_nodes[i], capacities[i], unit_costs[i])\n # Add node supplies\n for i in range(0, len(supplies)):\n min_cost_flow.SetNodeSupply(i, supplies[i])\n # Find the minimum cost flow between node s' and t'.\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\n print('Minimum cost:', min_cost_flow.OptimalCost())\n print('')\n print(' Arc Flow / Capacity Cost')\n for i in range(min_cost_flow.NumArcs()):\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\n print('%1s -> %1s %3s / %3s %3s' % (\n min_cost_flow.Tail(i),\n min_cost_flow.Head(i),\n min_cost_flow.Flow(i),\n min_cost_flow.Capacity(i),\n cost))\n # update arcs\n start = min_cost_flow.Tail(i)\n destin = min_cost_flow.Head(i)\n if start != s_prime and \\\n start != t_prime and \\\n start != x and \\\n destin != s_prime and \\\n destin != t_prime and \\\n destin != x:\n # if forward, increase flow. otherwise decrease.\n print(\"Processing edge ({}, {})\".format(start, destin))\n if start < destin:\n sup_flow = min_cost_flow.Flow(i)\n else:\n sup_flow = -min_cost_flow.Flow(i)\n temp_start = start\n start = destin\n destin = temp_start\n print(\"Has become ({}, {}) with sup {}\".format(start,\n destin,\n sup_flow))\n arc = self.get_arc(start, destin)\n if (sup_flow != 0) or (\"lower_bound\" not in \\\n self.arc_info[arc].keys()):\n print(\"We should add this\")\n old_flow = self.arc_info[arc][\"weight\"]\n new_flow = old_flow + sup_flow\n self.arc_info[arc][\"weight\"] = int(new_flow)\n print(\"Edge ({},{}) weight is changed from {} to {}\".format(\n start,\n destin,\n old_flow,\n new_flow))\n else:\n print('There was an issue with the min cost flow input.')\n #self.check_conservation_of_flow() # check that solution is valid","def find_ports(self, lines):\n ports = []\n left = None\n self.dists = []\n for line in lines:\n if left is None:\n if self.is_left(line):\n left = self.mid(line)\n else:\n if not self.is_left(line):\n ports.append(int(left[0] + self.mid(line)[0]) // 2)\n self.dists.append(left[0] - self.mid(line)[0])\n left = None\n # print(ports)\n return ports","def bfs_nodes_generator(graph, source, reverse=...):\n ...","def nodes_ratio(data: Data, position_against_soma=None, node_types=None, filter_layers=None):\n soma = data.morphology.get_soma()\n if position_against_soma=='above':\n criterion=lambda nod:((nod['type'] in node_types) if node_types is not None else True) and nod['y']<soma['y']\n elif position_against_soma=='below':\n criterion=lambda nod:((nod['type'] in node_types) if node_types is not None else True) and nod['y']>soma['y']\n else:\n criterion=lambda nod:nod['type'] in node_types if node_types is not None else True\n num_type_nodes = data.morphology.get_node_by_types(node_types)\n if filter_layers and isinstance(filter_layers, list):\n result = {}\n for layer in filter_layers:\n filter_layer_depth = data.reference_layer_depths.get(layer)\n y_min, y_max, is_scale = filter_layer_depth.pia_side, filter_layer_depth.wm_side, filter_layer_depth.scale\n if is_scale:\n selected_nodes = data.morphology.filter_nodes(lambda nod: criterion(nod) and y_min<nod['y']<y_max)\n else:\n selected_nodes = data.morphology.filter_nodes(lambda nod: criterion(nod) and nod['y']>y_min)\n result[layer]=len(selected_nodes)/len(num_type_nodes)\n return result\n else:\n selected_nodes = data.morphology.filter_nodes(criterion)\n return len(selected_nodes)/len(num_type_nodes)","def max_flow(self, source, sink):\n\n path = self.valid_path(source, sink, [])\n\n while path:\n # get the maximum possible flow that can be taken from this path:\n max_flow = min([edge.capacity for edge in path])\n for edge in path:\n self.edges[edge] += max_flow\n path = self.valid_path(source, sink, [])\n\n # Compute all the flows from the neighbors of source:\n return sum([self.edges[edge] for edge in self.adjacents[source]])","def get_fraction_links_active(self):\n active_links = 0\n for (a,b) in self.model.model.edges_iter():\n (a_id, a_traits) = self.model.get_agent_by_id(a)\n (b_id, b_traits) = self.model.get_agent_by_id(b)\n prob = analysis.calc_probability_interaction_axelrod(a_traits, b_traits)\n if prob > 0.0 and prob < 1.0:\n #log.debug(\"active link (%s %s) prob: %s a_trait: %s b_trait: %s\", a_id, b_id, prob, a_traits, b_traits)\n active_links += 1\n num_links_total = self.model.model.number_of_edges()\n #log.debug(\"active links: %s total links: %s\", active_links, num_links_total)\n fraction_active = float(active_links) / num_links_total\n return fraction_active","def find_sharpest_fork(nodes):\n pair_list = []\n Dis = np.array([])\n for n in nodes:\n if n.parent is not None:\n if n.parent.parent is not None:\n a = n.parent.children\n if(isinstance(a, list)):\n if(len(a)==2):\n n1 = a[0]\n n2 = a[1]\n if(len(n1.children) == 0 and len(n2.children) == 0):\n pair_list.append([n1 , n2])\n dis = LA.norm(a[0].xyz - a[1].xyz,2)\n Dis = np.append(Dis,dis)\n if(len(Dis)!= 0):\n (b,) = np.where(Dis == Dis.min())\n sharpest_pair = pair_list[b[0]]\n distance = Dis.min()\n else:\n sharpest_pair = [0,0]\n distance = 0.\n return sharpest_pair, distance","def bfs_paths(self, start: str, goal: str) -> List[Path]:\n queue = [(start, [start])]\n while queue:\n (node, path) = queue.pop(0)\n if node not in self.graph:\n yield []\n for _next in set(self.graph[node]) - set(path):\n if _next == goal:\n yield path + [_next]\n elif _next in self.graph:\n queue.append((_next, path + [_next]))","def get_all_social_paths(self, user_id): #each user v v each path V V\n # output example- {1: [1], 8: [1, 8], 10: [1, 10], 5: [1, 5], 2: [1, 10, 2], 6: [1, 10, 6], 7: [1, 10, 2, 7]}\n visited = {} # Note that this is a dictionary, not a set\n # Need to do a bfs using the user id\n # first step is to traverse the graph and record all the vertices as keys in visited using bft\n # then take those keys and use bfs on each, using user_id as the starting node and and the key as\n # the destination node\n\n # Modification of BFT\n # create an empty dict\n # q = Queue()\n q = []\n\n # init enqueue the starting node\n q.append(user_id)\n\n while len(q) > 0:\n # Dequeue the first item\n v = q.pop(0)\n # If it's not been visited:\n if v not in visited:\n # Mark as visited (i.e. add to the visited set)\n visited[v] = []\n\n # Do something with the node\n print(f\"Visited {v}\")\n\n # Add all neighbors to the queue\n for next_vert in self.friendships[v]:\n q.append(next_vert)\n\n # once visited is filled, then we start the bfs\n #print('vv',visited)\n possible_paths = {}\n #run a bfs for each key in visited\n for v in visited:\n possible_paths[v] = []\n \n if v == user_id:\n visited[v] = [user_id]\n\n path = []\n while len(path) < len(visited):\n\n # Add all neighbors to the queue\n for next_vert in self.friendships[v]:\n print(possible_paths[v])\n # copy the path\n # temp_path = list(path)\n # temp_path.append(next_vert)\n # add path to possible_paths\n path.append(next_vert)\n\n possible_paths[v].append(path) # HAVE TO USE QUEUE OR STACK, THEY ENSURE THE NEIGHBORS\n # FOLLOW THE CORRECT ORDER WHEN LOOPING \n\n if v == path[-1]:\n \n # IF SO, RETURN PATH\n visited[v] = path\n break\n\n # for x in visited:\n # bfs(user_id, x)\n # visited[x].add(path)\n \n print('pct of total users in network', len(visited[1])/len(visited))\n print('degrees of separation', len(visited[1]) - 1)\n return visited","def findrelations(planet, comingFrom, relations, borders):\n transfers = []\n transfersPath = 0\n \n relations = []\n for i in relations:\n if planet in i:\n # both orbits and centers can be saved except itself and the one coming from\n for j in i: \n if j not in (planet, comingFrom):\n relations.append(j)\n \n for rel in relations:\n if rel == \"SAN\":\n return transfers\n elif rel not in borders:\n transfers +=1\n transfers += findrelations(rel, comingFrom, relations, borders)\n \n transfers.append(transfersPath-1)\n return transfers","def _get_full_graph(self):","def get_fraction_links_active(self):\n active_links = 0\n for (a,b) in self.model.model.edges_iter():\n (a_id, a_traits) = self.model.get_agent_by_id(a)\n (b_id, b_traits) = self.model.get_agent_by_id(b)\n prob = analysis.calc_probability_interaction_extensible(a_traits, b_traits)\n if prob > 0.0 and prob < 1.0:\n #log.debug(\"active link (%s %s) prob: %s a_trait: %s b_trait: %s\", a_id, b_id, prob, a_traits, b_traits)\n active_links += 1\n num_links_total = self.model.model.number_of_edges()\n #log.debug(\"active links: %s total links: %s\", active_links, num_links_total)\n fraction_active = float(active_links) / num_links_total\n return fraction_active","def path_to_actor(self, source, target):\r\n #shortest path\r\n path = nx.shortest_path(self.graph, source, target)\r\n #shortest path length....\r\n len_path = nx.shortest_path_length(self.graph, source, target)\r\n return path, len_path/2","def createBridgeSets(blocksize,operating,MPSS):\n sets = tuple()\n xul = blocksize[0]-operating\n xdl = operating\n yul = int(blocksize[0]/2+operating)\n ydl = int(blocksize[0]/2-operating)\n xts = xul\n xbs = xdl\n for i in range(MPSS):\n sets+=(tuple(product(numpy.arange(xdl,xul,1),numpy.arange(ydl,yul,1))),)\n xdl+=operating\n xul-=operating\n ydl-=operating\n yul+=operating\n return sets,sets[::-1]","def detect_splits(self):\n logg.info(' abstracted graph will have {} nodes'.format(self.n_splits+1))\n indices_all = np.arange(self.X.shape[0], dtype=int)\n segs = [indices_all]\n if False: # this is safe, but not compatible with on-the-fly computation\n tips_all = np.array(np.unravel_index(np.argmax(self.Dchosen), self.Dchosen.shape))\n else:\n if self.iroot is not None:\n tip_0 = np.argmax(self.Dchosen[self.iroot])\n else:\n tip_0 = np.argmax(self.Dchosen[0]) # just a random index, here fixed to \"0\"\n tips_all = np.array([tip_0, np.argmax(self.Dchosen[tip_0])])\n # we keep a list of the tips of each segment\n segs_tips = [tips_all]\n if self.clusters_precomputed_names:\n self.segs_names_original = [', '.join(self.clusters_precomputed_names)]\n segs_undecided = [True]\n segs_adjacency = [[]]\n segs_distances = np.zeros((1, 1))\n segs_adjacency_nodes = [{}]\n # logg.info(' do not consider groups with less than {} points for splitting'\n # .format(self.min_group_size))\n for ibranch in range(self.n_splits):\n if self.clusters == 'unconstrained_segments':\n iseg, new_tips = self.select_segment(segs, segs_tips, segs_undecided)\n if iseg == -1:\n logg.info('... partitioning converged')\n break\n logg.info('... branching {}:'.format(ibranch + 1),\n 'split group', iseg)\n segs_distances = self.do_split(segs, segs_tips,\n segs_undecided,\n segs_adjacency,\n segs_distances,\n iseg, new_tips)\n else:\n logg.msg(' split', ibranch + 1, v=4)\n stop, segs_distances = self.do_split_constrained(segs, segs_tips,\n segs_adjacency,\n segs_adjacency_nodes,\n segs_distances)\n if stop: break\n\n # segments\n self.segs = segs\n self.segs_tips = segs_tips\n self.segs_sizes = []\n for iseg, seg in enumerate(self.segs): self.segs_sizes.append(len(seg))\n\n # the full, unscaled adjacency matrix\n self.segs_adjacency_full_attachedness = 1/segs_distances\n # if self.attachedness_measure == 'connectedness':\n # norm = np.sqrt(np.multiply.outer(self.segs_sizes, self.segs_sizes))\n # self.segs_adjacency_full_attachedness /= norm\n self.segs_adjacency_full_confidence, self.segs_adjacency_tree_confidence \\\n = self.compute_adjacency_confidence(\n self.segs_adjacency_full_attachedness,\n segs_adjacency,\n self.tree_based_confidence)\n np.fill_diagonal(self.segs_adjacency_full_attachedness, 0)","def get_GNS_cut(self):\n # we build the optimization around the casted digraph instead of multidigraph\n # for simplicity\n G = self.base_digraph\n s_1 = self.sources[0]\n s_2 = self.sources[1]\n t_1 = self.destinations[0]\n t_2 = self.destinations[1]\n edges = G.edges()\n nodes = G.nodes()\n\n try:\n\n # Great an gurobi instance of the optimization model\n m = Model(\"GNS\")\n m.setParam('OutputFlag', False)\n\n x_v = {}\n # vertex variables for s_1, t_1 cut\n for v in nodes:\n x_v[v] = m.addVar(vtype=GRB.BINARY)\n\n x_e = {}\n # edge variables for s_1, t_1 cut\n for (u,v) in edges:\n x_e[u,v] = m.addVar(vtype=GRB.BINARY)\n\n y_v = {}\n # vertex variables for s_2, t_2 cut\n for v in nodes:\n y_v[v] = m.addVar(vtype=GRB.BINARY)\n\n y_e = {}\n # edge variables for s_2, t_2 cut\n for (u,v) in edges:\n y_e[u,v] = m.addVar(vtype=GRB.BINARY)\n\n z_v = {}\n # vertex variables for s_2, t_1 cut\n for v in nodes:\n z_v[v] = m.addVar(vtype=GRB.BINARY)\n\n z_e = {}\n # edge variables for s_2, t_1 cut\n for (u,v) in edges:\n z_e[u,v] = m.addVar(vtype=GRB.BINARY)\n\n e = {}\n # GNS indicator variable\n for (u,v) in edges:\n e[u,v] = m.addVar(vtype=GRB.BINARY, obj=G[u][v]['capacity'])\n\n # Done with decision variable creation\n # update model\n m.update()\n\n # Constraints\n # 1. Constraints for s_1 - t_1 cut\n for (u,v) in edges:\n if (u,v) == (s_1, t_1):\n m.addConstr(x_e[u,v] >= 1)\n elif u == s_1:\n m.addConstr(x_v[v] + x_e[u,v] >= 1)\n elif v == t_1:\n m.addConstr(-x_v[u] + x_e[u,v] >= 0)\n else:\n m.addConstr(x_v[v] - x_v[u] + x_e[u,v] >= 0)\n\n # 2. Constraints for s_2 - t_2 cut\n for (u,v) in edges:\n if (u,v) == (s_2, t_2):\n m.addConstr(y_e[u,v] >= 1)\n elif u == s_2:\n m.addConstr(y_v[v] + y_e[u,v] >= 1)\n elif v == t_2:\n m.addConstr(-y_v[u] + y_e[u,v] >= 0)\n else:\n m.addConstr(y_v[v] - y_v[u] + y_e[u,v] >= 0)\n\n # 3. Constraints for s_2 - t_1 cut\n for (u,v) in edges:\n if (u,v) == (s_2, t_1):\n m.addConstr(z_e[u,v] >= 1)\n elif u == s_2:\n m.addConstr(z_v[v] + z_e[u,v] >= 1)\n elif v == t_1:\n m.addConstr(-z_v[u] + z_e[u,v] >= 0)\n else:\n m.addConstr(z_v[v] - z_v[u] + z_e[u,v] >= 0)\n\n # 4. Constraints for e[u,v] >= max(x_e[u,v], y_e[u,v], z_e[u,v])\n for (u,v) in edges:\n m.addConstr(e[u,v] >= x_e[u,v])\n m.addConstr(e[u,v] >= y_e[u,v])\n m.addConstr(e[u,v] >= z_e[u,v])\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n print \"Min GNS cut value = \" + str(m.objVal)\n print \"GNS cut edges:\"\n\n for u,v in edges:\n if e[u,v].x != 0:\n print (u,v)\n print \"s1-t1 cut edges in GNS:\"\n for u,v in edges:\n if x_e[u,v].x != 0:\n print (u,v)\n\n print \"s2-t2 cut edges in GNS:\"\n for u,v in edges:\n if y_e[u,v].x != 0:\n print (u,v)\n\n print \"s2-t1 cut edges in GNS:\"\n for u,v in edges:\n if z_e[u,v].x != 0:\n print (u,v)\n else:\n # something went wrong...err...\n print \"Something was wrong\"\n\n except GurobiError:\n print ('Error report from Gurobi')","def transmission (graph, r=.5, m=.5):\n\n routes = r*nx.adjacency_matrix(graph)\n medicn = m*sp.eye(nx.number_of_nodes(graph))\n\n return routes + medicn","def get_path(self, sim, app_name, message, topology_src, alloc_DES, alloc_module, traffic, from_des):\n node_src = topology_src\n DES_dst = alloc_module[app_name][message.dst]\n\n # print (\"GET PATH\")\n # print (\"\\tNode _ src (id_topology): %i\" % node_src)\n # print (\"\\tRequest service: %s \" % message.dst)\n # print (\"\\tProcess serving that service: %s \" % DES_dst)\n\n bestPath = []\n bestDES = []\n min_path_size = float('inf')\n myDigraph = graph2digraph(sim.topology.G)\n\n for des in DES_dst: ## In this case, there are only one deployment\n dst_node = alloc_DES[des]\n print (\"\\t Looking the path to id_node: %i\" % dst_node)\n\n path = list(nx.shortest_path(myDigraph, source=node_src, target=dst_node, weight='BW'))\n actual_path_size = nx.shortest_path_length(myDigraph, source=node_src, target=dst_node, weight='BW')\n\n # Calculo do fluxo maximo no grafo desde 1 ate 6\n # flow_value, flow_dict = list(nx.maximum_flow(myDigraph, _s=0, _t=6, capacity=\"BW\"))\n # print(\"MAXFLOW VALUE: \", flow_value)\n # print(\"MAXFLOW DICT: \", flow_dict)\n\n print (\"\\t\\t candidate to best path: \" + str(path) + \" Size = \" + str(actual_path_size))\n\n if actual_path_size < min_path_size:\n min_path_size = actual_path_size\n minPath = path\n bestDES = des\n\n bestPath = [minPath]\n bestDES = [des]\n print (\"best path is: \", bestPath, \" with weigth \", min_path_size)\n print \"---------------------------------------------------------\"\n return bestPath, bestDES","def greedy(self):\n # for each node, find the incoming link with the highest score.\n max_scores = {}\n max_sources = {}\n for source, target in self.iteredges():\n score = self.get_score(source, target)\n max_score = max_scores.get(target)\n if max_score is None or score > max_score:\n max_scores[target] = score\n max_sources[target] = source\n # then build a graph out of just these links.\n succs = dict((n, []) for n in self)\n for target, source in max_sources.items():\n succs[source].append(target)\n return Digraph(succs, self.get_score, self.get_label)","def internal_link_density(self, node_list):\n N = len(node_list)\n n_links = self.number_internal_links(node_list)\n if self.directed:\n return float(n_links) / (N * (N - 1))\n else:\n return 2 * float(n_links) / (N * (N - 1))","def __edgeRouter(self):\r\n def getEndpoint(nodeTuple, pointList, direction, isReversedEdge):\r\n \"\"\" Gets the nearest arrow endpoint. Handles edge reversal \"\"\"\r\n if((direction == 'start' and not isReversedEdge)\r\n or (direction == 'end' and isReversedEdge)): \r\n endNode = nodeTuple[0]\r\n if(isReversedEdge):\r\n ix = -2\r\n iy = -1\r\n else:\r\n ix = 0\r\n iy = 1\r\n else: \r\n endNode = nodeTuple[1]\r\n if(isReversedEdge):\r\n ix = 0\r\n iy = 1\r\n else:\r\n ix = -2 \r\n iy = -1 \r\n \r\n # Is it connected to a named port!?!\r\n if(endNode.isConnectedByNamedPort(edgeObject)):\r\n handler = endNode.getConnectedByNamedPortHandler(nodeTuple[2]) \r\n return dc.coords(handler)[:2]\r\n \r\n # Not a named port...\r\n return list(endNode.getClosestConnector2Point( endNode, pointList[ix], \r\n pointList[iy])) \r\n \r\n \r\n \r\n #todo: improve method for spline arrows + add comments + optimize?\r\n print '----------------Dummy Edge Routing-----------------'\r\n for dummyEdge in NodeWrapper.ID2LayerEdgeDict.keys():\r\n \r\n dummyList = NodeWrapper.ID2LayerEdgeDict[dummyEdge]\r\n dummyNode = dummyList[0]\r\n dummyChild = dummyNode.children.keys()[0]\r\n linkFlagList = dummyNode.children[dummyChild]\r\n \r\n # Real nodes at start/end of the edge\r\n edgeSourceNode = dummyNode.parents.keys()[0]\r\n edgeSourceNode = edgeSourceNode.getASGNode().graphObject_\r\n dummyNode = dummyList[-1]\r\n edgeTargetNode = dummyNode.children.keys()[0]\r\n #print 'Dummy edge number', dummyEdge,\r\n #print dummyList[0].parents.keys()[0].getName(), edgeTargetNode.getName()\r\n edgeTargetNode = edgeTargetNode.getASGNode().graphObject_\r\n nodeTuple = [edgeSourceNode, edgeTargetNode, None]\r\n \r\n # Some edges are internally reversed to break cycles, when drawing\r\n # this must be taken into account\r\n isReversedEdge = False\r\n edgesToRoute = []\r\n for linkNode, isReversed in linkFlagList:\r\n edgesToRoute.append(linkNode)\r\n if(isReversed):\r\n isReversedEdge = True\r\n \r\n # Get all the points the edge must pass through (sorted by layer order)\r\n dummyList.sort(lambda a, b: cmp(a.getLayer(), b.getLayer()))\r\n if(isReversedEdge):\r\n dummyList.reverse()\r\n sortedDummyRouteList = []\r\n for node in dummyList:\r\n sortedDummyRouteList += node.getEdgePosition()\r\n \r\n # Set the coordinates of the edge directly \r\n # This is complicated by the fact that AToM3 treats edges as two\r\n # segments that join poorly (for spline arrows)\r\n for edgeObject in edgesToRoute: \r\n dc = edgeObject.graphObject_.dc\r\n linkObj = edgeObject.graphObject_ \r\n tag = linkObj.tag\r\n \r\n if(isReversedEdge):\r\n inPoint = dc.coords( tag + \"2ndSeg0\" )[:2]\r\n outPoint = dc.coords( tag + \"1stSeg0\" )[:2]\r\n else:\r\n inPoint = dc.coords( tag + \"1stSeg0\" )[:2]\r\n outPoint = dc.coords( tag + \"2ndSeg0\" )[:2]\r\n \r\n #print 'Dummy route', sortedDummyRouteList\r\n numPoints = len(sortedDummyRouteList) / 2\r\n # Add 2 extra control points for odd case (to make splines nice)\r\n if(numPoints % 2 == 1):\r\n if(numPoints == 1):\r\n center = sortedDummyRouteList\r\n else:\r\n start = sortedDummyRouteList[:numPoints - 1]\r\n end = sortedDummyRouteList[numPoints + 1:]\r\n center = sortedDummyRouteList[numPoints - 1:numPoints + 1]\r\n \r\n if(not isReversedEdge):\r\n newMid1 = [center[0], center[1] - 20]\r\n newMid2 = [center[0], center[1] + 20]\r\n else:\r\n newMid2 = [center[0], center[1] - 20]\r\n newMid1 = [center[0], center[1] + 20]\r\n \r\n \r\n if(numPoints == 1):\r\n sortedDummyRouteList = newMid1 + center + newMid2 \r\n else:\r\n sortedDummyRouteList = start + newMid1 + center + newMid2 + end\r\n centerIndex = numPoints - 1 + 2\r\n \r\n # Add 1 extra control point for even case (to make splines nice)\r\n else:\r\n start = sortedDummyRouteList[:numPoints]\r\n end = sortedDummyRouteList[numPoints:]\r\n center = [start[-2] + (end[0] - start[-2]) / 2, \r\n start[-1] + (end[1] - start[-1]) / 2]\r\n sortedDummyRouteList = start + center + end \r\n centerIndex = numPoints\r\n \r\n # Now I know where the center is... so lets move the center object\r\n # Is the edge object a hyperlink?\r\n if(len(edgeObject.in_connections_ + edgeObject.out_connections_) > 2):\r\n fromObjs = []\r\n for semObj in edgeObject.in_connections_:\r\n fromObjs.append(semObj.graphObject_)\r\n toObjs = []\r\n for semObj in edgeObject.out_connections_:\r\n toObjs.append(semObj.graphObject_)\r\n optimizerHyperLink(dc, linkObj, fromObjs, toObjs, 0, 0, 0, center )\r\n continue\r\n \r\n else:\r\n linkObj.moveTo(* center)\r\n \r\n # Go through the 2 segments in the link\r\n nodeTuple[2] = edgeObject\r\n for connTuple in linkObj.connections:\r\n itemHandler = connTuple[0]\r\n direction = connTuple[1]\r\n \r\n if( direction ): \r\n inPoint = getEndpoint(nodeTuple, sortedDummyRouteList,\r\n 'start', isReversedEdge)\r\n\r\n segCoords = inPoint + sortedDummyRouteList[:centerIndex+2]\r\n else: \r\n outPoint = getEndpoint(nodeTuple, sortedDummyRouteList,\r\n 'end', isReversedEdge) \r\n segCoords = sortedDummyRouteList[centerIndex:] + outPoint\r\n segCoords = self.__reverseCoordList(segCoords)\r\n \r\n # Applies the changed coords to the canvas\r\n dc.coords( * [itemHandler] + segCoords ) \r\n \r\n # This may change the associated link drawings: \r\n # move them to the new point \r\n if( direction ):\r\n linkObj.updateDrawingsTo(inPoint[0], inPoint[1], itemHandler, \r\n segmentNumber=1)\r\n else:\r\n linkObj.updateDrawingsTo(outPoint[0], outPoint[1], itemHandler, \r\n segmentNumber=2)","def _mout_edges(nodes):\n n = nodes.shape[0]\n edges = []\n for i in range(0, n - 1):\n for j in range(i, n):\n if abs(nodes[i, 0] - nodes[j, 0]) > 1:\n break\n elif abs(nodes[i, 0] - nodes[j, 0]) == 1 and \\\n abs(nodes[i, 1] - nodes[j, 1]) == 0:\n edges.append([i, j])\n elif abs(nodes[i, 1] - nodes[j, 1]) == 1:\n edges.append([i, j])\n return edges","def naiveGlobalRouting(self):\n for e_list in self.s2e.values():\n for e in e_list:\n slot_path = []\n src_slot = self.v2s[e.src]\n dst_slot = self.v2s[e.dst]\n slot_path.append(src_slot)\n\n curr = src_slot\n len_x = src_slot.getLenX()\n len_y = src_slot.getLenY()\n\n # first go in X direction\n x_diff = curr.getPositionX() - dst_slot.getPositionX()\n if x_diff:\n dir = 'LEFT' if x_diff > 0 else 'RIGHT'\n for i in range(int(abs(x_diff/len_x))):\n curr = self.slot_manager.createSlotForRouting(curr.getNeighborSlotName(dir))\n slot_path.append(curr)\n\n y_diff = curr.getPositionY() - dst_slot.getPositionY()\n if y_diff:\n dir = 'DOWN' if y_diff > 0 else 'UP'\n for i in range(int(abs(y_diff/len_y))):\n curr = self.slot_manager.createSlotForRouting(curr.getNeighborSlotName(dir))\n slot_path.append(curr)\n \n assert curr == dst_slot\n \n slot_path = slot_path[1:-1] # exclude the src and the dst\n logging.info(f'{e.name}: {self.v2s[e.src].getName()} -> {self.v2s[e.dst].getName()} : ' + ' '.join(s.getName() for s in slot_path))\n self.e_name2path[e.name] = slot_path","def bandwidth_share(self, nodes_efficiency: Dict[str, float]) -> Dict[str, float]:\n pass","def run_dfs(self,s):\n if self.verbose: print('entering run_dfs with s = ',s)\n new_states = [self.succ(s,a) for a in self.actions(s)]\n results = []\n\n for ns in new_states:\n if self.verbose: print('considering new state = ',ns)\n end = self.is_end(ns)\n if end:\n result = self.result(ns)\n if result is not None:\n results.append(result)\n else:\n results += self.run_dfs(ns)\n return results","def sage_graph(self):\n self.fe.load_cache()\n edges = []\n is_bipartite = self.variant.is_bipartite()\n for X in self.L:\n for Y in self.L:\n a = self.op_norm(X, Y)\n if not self.K.is_zero(a):\n for c in self.K.unit_group:\n d = a - c\n if X != Y or c < d or is_bipartite:\n edges.append(((X, c, False), (Y, d, is_bipartite)))\n if X == Y and not is_bipartite:\n break\n return sage.all.Graph(edges)","def get_network_ratio(df, edges, initial_buffer=500):\n\n # intersection-based join\n buff = edges.buffer(0.01) # to avoid floating point error\n inp, res = buff.sindex.query_bulk(df.geometry, predicate=\"intersects\")\n intersections = (\n df.iloc[inp]\n .reset_index(drop=True)\n .intersection(buff.iloc[res].reset_index(drop=True))\n )\n mask = intersections.area > 0.0001\n intersections = intersections[mask]\n inp = inp[mask]\n lengths = intersections.area\n grouped = lengths.groupby(inp)\n totals = grouped.sum()\n ints_vect = []\n for name, group in grouped:\n ratios = group / totals.loc[name]\n ints_vect.append({res[item[0]]: item[1] for item in ratios.iteritems()})\n\n edge_dicts = pd.Series(ints_vect, index=totals.index)\n\n # nearest neighbor join\n nans = df.index.difference(edge_dicts.index)\n buffered = df.iloc[nans].buffer(initial_buffer)\n additional = []\n for orig, geom in zip(df.iloc[nans].geometry, buffered.geometry):\n query = edges.sindex.query(geom, predicate=\"intersects\")\n b = initial_buffer\n while query.size == 0:\n query = edges.sindex.query(geom.buffer(b), predicate=\"intersects\")\n b += initial_buffer\n additional.append({edges.iloc[query].distance(orig).idxmin(): 1})\n\n additional = pd.Series(additional, index=nans)\n ratios = pd.concat([edge_dicts, additional]).sort_index()\n result = pd.DataFrame()\n result[\"edgeID_keys\"] = ratios.apply(lambda d: list(d.keys()))\n result[\"edgeID_values\"] = ratios.apply(lambda d: list(d.values()))\n result.index = df.index\n return result","def construct_fast_graph_connection(coord_list, radie):\n\n connection_distance = []\n connection = []\n coord_list_tree = scipy.spatial.cKDTree(coord_list)\n for j, data in enumerate(coord_list):\n '''save nodes which are in range'''\n connections_ckd = coord_list_tree.query_ball_point(data, radie)\n for i in connections_ckd:\n #only save upper half of the matrix\n if i > j:\n #save the connection\n connection.append([j, i])\n #save the relative distance of the nodes\n connection_distance.append(np.hypot(coord_list[i,0]-data[0], coord_list[i,1]-data[1]))\n\n connection_distance = np.array(connection_distance)\n connection = np.array(connection)\n\n\n return connection, connection_distance","def test_find_path_dfs():\n g = Graph()\n node_1 = Node({'A':['B','C']})\n g.add(node_1)\n node_2 = Node({'B':['C','D']})\n g.add(node_2)\n node_3 = Node({'C':['D']})\n g.add(node_3)\n node_4 = Node({'D':['C']})\n g.add(node_4)\n node_5 = Node({'E':['C']})\n g.add(node_5)\n\n # zero path between node_1 and node_5\n path_0 = g.find_path_dfs(node_1, node_5)\n assert path_0 == None\n\n # only one path between node_5 and node_4\n path_1 = g.find_path_dfs(node_5, node_4)\n assert [ node.name for node in path_1 ] == [ node_5.name, node_3.name, node_4.name ]\n\n # three paths between node_1 and node_3, verify anyone of the three is returned\n path_3 = g.find_path_dfs(node_1, node_3)\n assert [ node.name for node in path_3 ] == [ node_1.name, node_2.name, node_3.name ] or \\\n [ node.name for node in path_3 ] == [ node_1.name, node_2.name, node_4.name, node_3.name ] or \\\n [ node.name for node in path_3 ] == [ node_1.name, node_3.name ]","def trapezium_rule(f, m, x, a, b, n):\n h = (b-a)/float(n)\n s = 0.5*(f(m, x, a) + f(m, x, b))\n for i in range(n):\n s = s + f(m, x, a + i*h)\n return h*s","def compute_equal_flow_allocations(target_graph, K=3):\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n flow_allocation_seed_number = 0xDEAD_BEEF\n np.random.seed(flow_allocation_seed_number)\n flows = []\n for node in target_graph.nodes:\n possible_destination_nodes = set(target_graph.nodes) - set([node])\n [destination_node] = np.random.choice(list(possible_destination_nodes), 1, replace=False)\n # shortest_paths = all_shortest_paths(target_graph, node, destination_node.item())\n shortest_paths = sorted(nx.all_simple_paths(target_graph, node, destination_node.item(),\n cutoff=3),\n key=lambda p: len(p))\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\n the_flow = Flow( source_node = node\n , destination_node = destination_node.item()\n , flow_tx_rate = 10.0\n , paths = k_shortest_paths\n , splitting_ratio = [1/K]*K\n )\n flows.append(the_flow)\n \n return flow_allocation_seed_number, flows","def get_urls(*params: str, num_of_links: int = 1) -> list:\n urls = []\n try:\n for i in range(num_of_links):\n url = \"https://finviz.com/screener.ashx?v=111\"\n codes = ','.join(rts_codes[len(rts_codes)*(num_of_links - i - 1)//num_of_links:(len(rts_codes)*(num_of_links - i)//num_of_links)])\n payload = {\"FT\": 2,\"f\": params,\"t\": codes}\n req = requests.get(url, params=payload)\n if len(req.url) > 2900:\n urls = []\n num_of_links += 1\n urls = get_urls(*params, num_of_links=num_of_links)\n else:\n urls.append(req.url)\n return (urls)\n except Exception as e:\n print (e)\n return None","def pair_frame(captured_file, frame_seq):\n rid = 0\n all_frame = {}\n fs_relation = {} # frame_stream_relation, mapping from stream number to one or more rid\n get_pairing = \"tshark -2 -r {} -R '' -Y 'frame.number > 0 && http.request' -T fields -e tcp.stream -e frame.number -e http.response_in\"\n \n # Run get_pairing command\n pairs = run_command(get_pairing.format(captured_file), False)\n\n # Associate each request and response node with its frame number in a dict\n for i in range(0, len(frame_seq)):\n cur_node = frame_seq[i]\n all_frame[cur_node.get_frame()] = cur_node\n \n all_stream = []\n for p in pairs:\n pl = p.decode('utf8').rstrip('\\n').split('\\t')\n cur_sn = int(pl[0]) # current_stream_number\n try:\n fs_relation[cur_sn]\n except KeyError:\n fs_relation[cur_sn] = []\n all_stream.append(cur_sn)\n fs_relation[cur_sn].append(rid)\n\n req_fn = int(pl[1]) # request_frame\n all_frame[req_fn].set_req()\n all_frame[req_fn].set_rid(rid)\n\n try:\n res_fn = int(pl[2]) # response_frame\n all_frame[res_fn].set_res()\n all_frame[res_fn].set_rid(rid)\n except ValueError:\n # Handle request without response here\n pass\n\n rid += 1\n\n return frame_seq, fs_relation, all_stream","def _split_forced(self, node):\n # compute the split\n _vec = 0\n sorted_idxs = np.argsort(self.E[node.ids, _vec]).squeeze()\n n = len(sorted_idxs) // 2\n _lids = node.ids[sorted_idxs[:n]]\n _rids = node.ids[sorted_idxs[n:]]\n # compute the score of the new tubes only\n _sl = self.get_tube_score(_lids)\n _sr = self.get_tube_score(_rids)\n # register the split\n node.has_children = True\n node.thresh = np.median(self.E[node.ids, _vec]) # arbitrary\n # Note: median would not ensure equal size (because of duplicate values)\n left = SpectralNode(_lids, _vec, score=_sl, name=node.name + \"0\")\n right = SpectralNode(_rids, _vec, score=_sr, name=node.name + \"1\")\n\n return left, right","def _semiconnected_ramps(slope1=1., slope2=1.) -> cs.Network:\n\n class _Ramp(cs.Simulator):\n \"\"\"Used in tests to mock a simulator\"\"\"\n def __init__(self, slope: Fraction, step_size: Fraction):\n self._step_size = step_size\n self._x = Fraction(0)\n self._slope = slope\n\n @property\n def inputs(self):\n return {'u': sdf.InputPort(float, 1)}\n\n @property\n def outputs(self):\n return {'y': sdf.OutputPort(float, 1)}\n\n def calculate(self, input_tokens):\n self._x += self._slope * self._step_size\n return {'y': [float(self._x)]}\n\n def construct_ramp1(step_size):\n return _Ramp(slope1, step_size)\n\n def construct_ramp2(step_size):\n return _Ramp(slope2, step_size)\n\n slaves = {'Ramp1': construct_ramp1, 'Ramp2': construct_ramp2}\n\n connections = {\n cs.Dst('Ramp1', 'u'): cs.Src('Ramp2', 'y'),\n cs.Dst('Ramp2', 'u'): cs.Src('Ramp1', 'y'),\n }\n return slaves, connections","def bfs(self, s):\n g = Graph(attr={DIRECTED: True})\n root = self.get_vertex(s)\n root.attributes[DISCOVERED] = True\n q = collections.deque()\n adjacent_type = '+' if DIRECTED in self.attr and self.attr[\n DIRECTED] else None\n # Insert root node in graph and queue\n g.add_vertex(root)\n q.append(s)\n\n while (len(q) > 0):\n v = q.popleft()\n for e in self.get_adjacent_vertices_by_vertex(v, adjacent_type):\n w = self.get_vertex(e)\n if DISCOVERED not in w.attributes or w.attributes[\n DISCOVERED] is False:\n w.attributes[DISCOVERED] = True\n q.append(w.id)\n g.add_vertex(w)\n g.add_edge(edge.Edge(v, e), True)\n return g","def a_star_alg(self, p1: int, p2: int, max_level: int = 1000):\r\n \r\n # Create start and end node\r\n start_node = Node(None, p1, self.node_dict[p1])\r\n start_node.g = start_node.h = start_node.f = 0\r\n end_node = Node(None, p2, self.node_dict[p2])\r\n end_node.g = end_node.h = end_node.f = 0\r\n\r\n # Initialize both open and closed list\r\n open_list = []\r\n closed_list = []\r\n\r\n # Add the start node\r\n open_list.append(start_node)\r\n\r\n # Loop until you find the end\r\n level = 0\r\n while len(open_list) > 0 and level < max_level:\r\n level += 1\r\n\r\n # Get the current node (the node in open_list with the lowest cost)\r\n current_node = open_list[0]\r\n current_index = 0\r\n for index, item in enumerate(open_list):\r\n if item.f < current_node.f:\r\n current_node = item\r\n current_index = index\r\n\r\n # Pop current off open list, add to closed list\r\n open_list.pop(current_index)\r\n closed_list.append(current_node)\r\n\r\n # Found the goal\r\n if current_node == end_node:\r\n path = []\r\n distance = current_node.g\r\n current = current_node\r\n while current is not None:\r\n path.append(current.number)\r\n current = current.parent\r\n\r\n return path[::-1], distance # Return reversed path\r\n\r\n # Generate children\r\n children = []\r\n for new_number in self.road_tree[current_node.number]: # Adjacent nodes\r\n new_node = Node(current_node, new_number, self.node_dict[new_number])\r\n children.append(new_node)\r\n\r\n # Loop through children\r\n for child in children:\r\n append_to_open_list = False\r\n\r\n # Create the f, g, and h values\r\n child.g = current_node.g + self.road_dict[(current_node.number, child.number)]\r\n child.h = sqrt((child.x - end_node.x) ** 2 + (child.y - end_node.y) ** 2) / 200\r\n child.f = child.g + child.h\r\n\r\n # Child is already in the closed list\r\n closed_list, append_to_open_list = self.check_in_list(child, closed_list, append_to_open_list)\r\n\r\n # Child is already in the open list\r\n open_list, append_to_open_list = self.check_in_list(child, open_list, append_to_open_list)\r\n\r\n # Add the child to the open list\r\n if append_to_open_list:\r\n open_list.append(child)\r\n\r\n return [], 1e10","def find_all_cycles(s,graph):\n\n grph = u.edge_to_list_dict(graph)\n node_cnt = len(grph)\n k = z.Int(\"k\")\n syms = [z.Int('node%s'%i) for i in range(node_cnt)]\n\n # s.add(syms[0] == 0) # start node is a 0\n s.add(k < node_cnt)\n s.add(k > 1)\n\n o = z.Optimize()\n\n # for source, sinks in sgraph.s_adj_list():\n for i in range(node_cnt):\n s.add(syms[i] >= 0)\n s.add(syms[i] <= k)\n s.add(z.Or([syms[j] == ((syms[i] + 1) % k) for j in grph[i]]) == (syms[i] == 0))\n\n\n r = []\n m = []\n\n # o.minimize(z.Sum([syms[i] for i in range(node_cnt)]))\n s.add(z.Product([syms[i] for i in range(node_cnt)]) == 0)\n done = False\n while not done:\n if s.check() == z.sat:\n m = s.model()\n r.append(m)\n s.add(k != m[k])\n else:\n done = True\n\n return r","def calc_lp(self, demands: Demand, routing: Routing) -> float:\n epsilon = self.epsilon\n\n # Create the linear solver with the GLOP backend.\n solver = pywraplp.Solver('flow_utilisation_lp',\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\n\n ## VARIABLES\n # Flow variables, the amount of flow along each edge\n # stored as a list flow_variables[ith_flow][jth_edge]\n flow_variables = []\n for i in range(len(self.commodities)):\n flow_variable_edges = []\n for j in range(len(self.edges)):\n flow_variable_edges.append(\n solver.NumVar(0, solver.infinity(), '({},{})'.format(i, j)))\n flow_variables.append(flow_variable_edges)\n\n ## CONSTRAINTS\n # Flow from source constraint (net flow must equal demand)\n conservation_source_constraints = []\n for i, commodity in enumerate(self.commodities):\n # create constraint\n constraint_i = solver.Constraint(demands[i] - epsilon,\n demands[i] + epsilon,\n '(source,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[0])]:\n # out flow is positive\n constraint_i.SetCoefficient(flow_variables[i][edge_index], 1)\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[0])]:\n # in flow is negative\n constraint_i.SetCoefficient(flow_variables[i][edge_index], -1)\n conservation_source_constraints.append(constraint_i)\n\n # Flow to sink constraint (in flow must equal demand, out must be zero)\n conservation_sink_constraints = []\n for i, commodity in enumerate(self.commodities):\n # create in flow constraint\n constraint_i_in = solver.Constraint(-demands[i] - epsilon,\n -demands[i] + epsilon,\n '(sink_in,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[1])]:\n # in flow is negative\n constraint_i_in.SetCoefficient(flow_variables[i][edge_index],\n -1)\n conservation_sink_constraints.append(constraint_i_in)\n\n constraint_i_out = solver.Constraint(0, 0,\n '(sink_out,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[1])]:\n # out flow is positive\n constraint_i_out.SetCoefficient(flow_variables[i][edge_index],\n 1)\n conservation_sink_constraints.append(constraint_i_out)\n\n # Flow at transit node constraint (net flow must be zero)\n conservation_transit_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.graph.number_of_nodes()):\n if j != commodity[0] and j != commodity[1]:\n # create constraint\n constraint_j = solver.Constraint(-epsilon, +epsilon,\n '(transit,{},{})'.format(i,\n j))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(j)]:\n # out flow is positive\n constraint_j.SetCoefficient(\n flow_variables[i][edge_index],\n 1)\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(j)]:\n # in flow is negative\n constraint_j.SetCoefficient(\n flow_variables[i][edge_index],\n -1)\n constraints_flow_i.append(constraint_j)\n conservation_transit_constraints.append(constraints_flow_i)\n\n # Flow splitting at transit constraints (edge flow must be correct split of\n # in flow)\n splitting_ratio_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.graph.number_of_nodes()):\n # Sink has not such constraint and we handle source differently\n if j != commodity[1] and j != commodity[0]:\n in_edges = [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(j)]\n out_edges = [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(j)]\n\n # separate constraint for split of each out_edge taking into\n # account all in_edges\n for out_edge_index in out_edges:\n # create constraint\n constraint_edge = \\\n solver.Constraint(-epsilon, +epsilon,\n '(split,{},{},{})'.format(\n i, j,\n out_edge_index))\n split_ratio = routing[i][out_edge_index]\n # flow on out edge\n constraint_edge.SetCoefficient(\n flow_variables[i][out_edge_index], 1)\n for in_edge_index in in_edges:\n # should equal sum of flow on all in edges scaled by\n # split ratio\n constraint_edge.SetCoefficient(\n flow_variables[i][in_edge_index],\n -1 * split_ratio)\n constraints_flow_i.append(constraint_edge)\n splitting_ratio_constraints.append(constraints_flow_i)\n\n # Flow splitting at source constraints (edge flow must be correct split of\n # in flow + demand)\n source_splitting_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n in_edges = [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[0])]\n out_edges = [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[0])]\n for out_edge_index in out_edges:\n # create constraint\n split_ratio = routing[i][out_edge_index]\n split_demand = split_ratio * demands[i]\n constraint_edge = \\\n solver.Constraint(split_demand - epsilon,\n split_demand + epsilon,\n '(split,{},{},{})'.format(i, j,\n out_edge_index))\n # flow on out edge\n constraint_edge.SetCoefficient(\n flow_variables[i][out_edge_index], 1)\n for in_edge_index in in_edges:\n # should equal sum of flow on all in edges scaled by split ratio\n constraint_edge.SetCoefficient(\n flow_variables[i][in_edge_index],\n -1 * split_ratio)\n constraints_flow_i.append(constraint_edge)\n source_splitting_constraints.append(constraints_flow_i)\n\n solver.Solve()\n\n result_status = solver.Solve()\n\n utilisation = np.zeros(\n (len(self.commodities), self.graph.number_of_edges()))\n # # extract the actual routing. Useful for debugging, maybe use to bootstrap\n # assignment = np.zeros(\n # (len(self.commodities), self.graph.number_of_edges()))\n\n # if routing is really that bad, just bail and give a sad result\n if result_status == solver.NOT_SOLVED or result_status == solver.INFEASIBLE:\n return 1.0\n\n for i in range(len(self.commodities)):\n for j in range(self.graph.number_of_edges()):\n utilisation[i][j] = flow_variables[i][j].solution_value() / \\\n self.edges[j][2]['weight']\n # assignment[i][j] = flow_variables[i][j].solution_value()\n\n return np.max(np.sum(utilisation, axis=0))","def bfs(self) -> dict:\n distances_graph = {}\n\n # BFS from middle to the robot start point\n start = self.center\n search = self.start\n\n distances_graph[start] = 0\n queue = collections.deque([start])\n\n while True:\n # Get next node\n node = queue.pop()\n\n if node == search:\n # If this is the one we need, search no more\n break\n\n for neighbor in self.graph[node]:\n if neighbor not in distances_graph:\n # If distance to neighbor hasn't been calculated, calculate it\n queue.appendleft(neighbor)\n distances_graph[neighbor] = distances_graph[node] + 1\n\n return distances_graph","def setup_nodes(server_node, road_node, road_segment_point):\n\n # Create working server node data subset excluding unneeded fields\n snode = [{'id': i,\n 'shapeid': item['shapeid'],\n 'x': float(item['x']),\n 'y': float(item['y']),\n 'nearest_pt': None,\n 'nearest_pt_sl_dist': float(\"inf\"),\n 'color_num': (int(item['shapeid']) + CM_OFFSET) % NUM_COLORS}\n for i, item in enumerate(server_node)]\n\n # Create working road node data subset excluding unneeded fields\n # (note: road nodes consist of junctions and road ends)\n rnode = []\n prev_coord = []\n for i, item in enumerate(road_node):\n if [item['x'], item['y']] not in prev_coord: # exclude duplicates\n rnode.append({'id': i,\n 'shapeid': item['shapeid'],\n 'x': float(item['x']),\n 'y': float(item['y']),\n 'best_server': None,\n 'color_num': GREY})\n prev_coord.append([item['x'], item['y']])\n\n # Create working road point data subset excluding unneeded fields\n rpoint = []\n point = 0\n for i in range(len(road_segment_point)):\n id = road_segment_point[i]['shapeid']\n rpoint.append({'id': i,\n 'shapeid': id,\n 'point': point,\n 'x': float(road_segment_point[i]['x']),\n 'y': float(road_segment_point[i]['y']),\n 'lowest_cost': float(\"inf\"),\n 'best_server': None,\n 'color_num': GREY})\n if i < len(road_segment_point) - 1:\n id_next = road_segment_point[i + 1]['shapeid']\n if id == id_next:\n point += 1\n else:\n point = 0\n\n # Convert adjacent road segment endpoints to lines (x1, y1) to (x2, y2)\n rseg = []\n line = 0\n seg = 0\n for i in range(len(rpoint[:-1])):\n id = rpoint[i]['shapeid']\n id_next = rpoint[i + 1]['shapeid']\n if id == id_next:\n rseg.append({'id': line,\n 'shapeid': id,\n 'segment': seg,\n 'point1': rpoint[i]['id'],\n 'x1': float(rpoint[i]['x']),\n 'y1': float(rpoint[i]['y']),\n 'point2': rpoint[i + 1]['id'],\n 'x2': float(rpoint[i + 1]['x']),\n 'y2': float(rpoint[i + 1]['y']),\n 'best_server': None,\n 'color_num': GREY})\n line += 1\n seg += 1\n else:\n seg = 0\n\n return snode, rnode, rpoint, rseg","def routes(self) -> List[Tuple[int, bytes]]:\n raise NotImplementedError() # pragma: no cover"],"string":"[\n \"def traverse_graph(F, f, s, t, u, sr):\\n def get_paths_for_flow(F, s, f):\\n \\\"\\\"\\\"\\n RETURNS\\n A set of outgoing links and corresponding splitting ratios for flow f\\n at node s\\n \\\"\\\"\\\"\\n links = [((u, v), split_ratio) \\n for (flow_id, u, v), split_ratio in F.items() \\n if flow_id == f and u == s and split_ratio > 0.001]\\n return links\\n \\n if u == t:\\n return [([t], sr)]\\n\\n outgoing_links = get_paths_for_flow(F, u, f)\\n paths_to_t = []\\n\\n for ((current_node, next_hop), split_ratio) in outgoing_links:\\n paths_from_u_to_t = traverse_graph(F, f, s, t, next_hop, split_ratio) \\n paths_to_t.extend(paths_from_u_to_t)\\n\\n paths_to_t_with_u = []\\n for path in paths_to_t:\\n nodes, sr = path\\n new_path = [u] + nodes\\n paths_to_t_with_u.append((new_path, sr))\\n\\n return paths_to_t_with_u\",\n \"def step(nodes, outputs, edges):\\n flowed = []\\n for node_name in nodes.copy():\\n if node_name in flowed:\\n continue\\n if len(nodes[node_name]) == 2:\\n if node_name in flowed:\\n continue\\n node = [int(value) for value in nodes[node_name]]\\n low_value, high_value = min(node), max(node)\\n low_flow, high_flow = edges[node_name] \\n low_dictionary, low_node_name = low_flow\\n high_dictionary, high_node_name = high_flow\\n low_node = low_dictionary.get(low_node_name, tuple())\\n high_node = high_dictionary.get(high_node_name, tuple())\\n low_dictionary[low_node_name] = low_node + (str(low_value),)\\n high_dictionary[high_node_name] = high_node + (str(high_value),)\\n nodes[node_name] = tuple()\\n if low_dictionary is nodes:\\n flowed.append(low_node_name)\\n if high_dictionary is nodes:\\n flowed.append(high_node_name)\\n return nodes, outputs, edges\",\n \"def split_at_nodes(shp):\\n nodes = find_nodes(shp)\\n nodeIds = list(nodes)\\n nodeIds.sort()\\n nodeIds = dict([(node,i) for i,node in enumerate(nodeIds)])\\n \\n for road in shp:\\n vrts = road.vertices\\n midVrts = set(road.vertices[1:-1]) #we know end points are nodes\\n midNodes = midVrts.intersection(nodes) # find any nodes in the middle of the feature.\\n midIdx = [vrts.index(node) for node in midNodes] # Get their indices\\n midIdx.sort()\\n if midIdx:\\n #print vrts\\n starts = [0]+midIdx\\n stops = [x+1 for x in midIdx]+[None]\\n for start,stop in zip(starts,stops):\\n feat = pysal.cg.Chain(vrts[start:stop])\\n rec = (nodeIds[feat.vertices[0]],nodeIds[feat.vertices[-1]],False)\\n yield feat,rec\\n else:\\n rec = (nodeIds[road.vertices[0]],nodeIds[road.vertices[-1]],False)\\n yield road,rec\",\n \"def _split(self):\\r\\n \\r\\n temp = [self.upstream.demand]\\r\\n for item, p in zip(self.downstream, self.priority):\\r\\n temp.append(item.supply/p)\\r\\n \\r\\n flow = min(temp) # total flow\\r\\n \\r\\n self.upstream.outflow = flow\\r\\n \\r\\n for item, p in zip(self.downstream, self.priority):\\r\\n item.inflow = p * flow\",\n \"def ford_fulkerson_algorithm(graph: np.ndarray, source: int, sink: int) -> np.ndarray:\\r\\n\\r\\n residual_graph = copy.deepcopy(graph)\\r\\n row = len(residual_graph)\\r\\n parent = [-1] * row\\r\\n max_flow = 0\\r\\n\\r\\n if source == sink or sink < 0 or source < 0 or source >= row or sink >= row:\\r\\n raise WrongInputException('Wrong input source/sink vertice(s)')\\r\\n\\r\\n while bfs(residual_graph, row, source, sink, parent):\\r\\n\\r\\n path_flow = float(\\\"Inf\\\")\\r\\n s = sink\\r\\n while s != source:\\r\\n path_flow = min(path_flow, residual_graph[parent[s]][s])\\r\\n s = parent[s]\\r\\n\\r\\n max_flow += path_flow\\r\\n\\r\\n v = sink\\r\\n while v != source:\\r\\n u = parent[v]\\r\\n residual_graph[u][v] -= path_flow\\r\\n residual_graph[v][u] += path_flow\\r\\n v = parent[v]\\r\\n print(\\\"Max flow: %d\\\" % max_flow)\\r\\n\\r\\n return residual_graph\",\n \"def split_edges(self, maximum_distance):\\n \\\"\\\"\\\" Iterate through the vertices of each section. For each vertex v, evaluate edges for which v is a source.\\n If an edge of weight greater than maximum_distance, then split it. \\\"\\\"\\\"\\n for section_id in self.sections:\\n utils.print_progress(len(self.sections), prefix='splitting edges')\\n current_section = [] # Need to update the section data after splitting the edges.\\n for source in self.sections[section_id]:\\n current_section.append(source)\\n edges_to_remove = [] # If an edge is split, it will need to be removed.\\n for edge in self.graph.get_out_edges(source):\\n if self.edge_weights[edge] > maximum_distance:\\n target = edge[1] # edge is a numpy array of [source, target, edge]. Select target.\\n edges_to_remove.append(self.graph.edge(edge[0], edge[\\n 1])) # If an edge is split, the original edge should be removed.\\n\\n new_edge_count = int(math.ceil(self.edge_weights[edge] / maximum_distance))\\n new_edge_distance = self.edge_weights[edge] / new_edge_count\\n current_point = shapes.Point.from_list(\\n list(self.node_locations[source]) + [self.node_heading[target]])\\n previous_vertex = source\\n for _ in range(new_edge_count):\\n current_point = utils.offset_point(current_point, new_edge_distance, current_point.bearing)\\n current_vertex = self.graph.add_vertex()\\n current_section.append(current_vertex) # The new vertex becomes a part of the section.\\n \\\"\\\"\\\" Populate the property map for the new vertex. Inherit values from the target node,\\n unless the target node is a junction node. Then inherit values from the source. \\\"\\\"\\\"\\n self.node_locations[current_vertex] = current_point.as_list()\\n self.node_heading[current_vertex] = current_point.bearing\\n property_vertex = source if not self.junctions[target] else target\\n self.node_speed_limit[current_vertex] = self.node_speed_limit[property_vertex]\\n self.node_width[current_vertex] = self.node_width[property_vertex]\\n self.node_id[current_vertex] = self.node_id[property_vertex]\\n\\n \\\"\\\"\\\" Create an edge between the previous vertex and the newly created vertex, \\n and update the edge weight property map. \\\"\\\"\\\"\\n current_edge = self.graph.add_edge(previous_vertex, current_vertex)\\n self.edge_weights[current_edge] = new_edge_distance\\n\\n # The current vertex becomes the previous vertex in the next step.\\n previous_vertex = current_vertex\\n\\n \\\"\\\"\\\" Create an edge between the last new vertex that was created and the target of the\\n original edge which is being split, and update the property map. \\\"\\\"\\\"\\n self.edge_weights[self.graph.add_edge(previous_vertex, target)] = new_edge_distance\\n list(map(self.graph.remove_edge, edges_to_remove)) # Remove all relevant edges\\n self.sections[section_id] = current_section # Update the section with the new vertices\",\n \"def dfs(x, p, step):\\n disc[x] = low[x] = step\\n for xx in graph.get(x, []): \\n if disc[xx] == inf: \\n step += 1\\n dfs(xx, x, step)\\n low[x] = min(low[x], low[xx])\\n if low[xx] > disc[x]: ans.append([x, xx]) # bridge\\n elif xx != p: low[x] = min(low[x], disc[xx])\",\n \"def get_flow_2frames(self, x):\\n b, n, c, h, w = x.size()\\n x_1 = x[:, :-1, :, :, :].reshape(-1, c, h, w)\\n x_2 = x[:, 1:, :, :, :].reshape(-1, c, h, w)\\n flows_backward = self.spynet(x_1, x_2)\\n flows_backward = [flow.view(b, n - 1, 2, h // 2 ** i, w // 2 ** i) for flow, i in zip(flows_backward, range(4))]\\n flows_forward = self.spynet(x_2, x_1)\\n flows_forward = [flow.view(b, n - 1, 2, h // 2 ** i, w // 2 ** i) for flow, i in zip(flows_forward, range(4))]\\n return flows_backward, flows_forward\",\n \"def sg_hops (self):\\n return (link for s, d, link in self.network.edges_iter(data=True) if\\n link.type == Link.SG)\",\n \"def compute_greedy_flow_allocations( target_graph\\n , flow_selection_fn\\n , seed_number=DEFAULT_SEED_NUMBER):\\n\\n flow_allocation_seed_number = seed_number\\n np.random.seed(flow_allocation_seed_number)\\n\\n link_utilization = {tuple(sorted(link_tuple)): 0.0 for link_tuple in target_graph.edges}\\n flows = []\\n\\n while True:\\n capacity_was_exceeded = False\\n\\n source_node, destination_node = flow_selection_fn(target_graph.nodes)\\n flow_tx_rate = np.random.uniform(FLOW_TX_RATE_LOWER_BOUND, FLOW_TX_RATE_UPPER_BOUND)\\n\\n connecting_paths = list(node_disjoint_paths(target_graph, source_node, destination_node))\\n disjoint_path_count = len(connecting_paths)\\n flow_rate_per_subpath = flow_tx_rate / disjoint_path_count\\n for path in [nx.utils.pairwise(p_i) for p_i in connecting_paths]:\\n for u, v in [tuple(sorted(t_i)) for t_i in path]:\\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\\n capacity_was_exceeded = True\\n break\\n link_utilization[u, v] += flow_rate_per_subpath\\n if capacity_was_exceeded:\\n break\\n if capacity_was_exceeded:\\n break\\n\\n the_flow = Flow( source_node = source_node\\n , destination_node = destination_node\\n , flow_tx_rate = flow_tx_rate\\n , paths = connecting_paths\\n , splitting_ratio = [1.0/disjoint_path_count]*disjoint_path_count\\n )\\n flows.append(the_flow)\\n return flows, link_utilization\",\n \"def compute_flow(self, lqs):\\n n, t, c, h, w = lqs.size()\\n lqs_1 = lqs[:, :-1, :, :, :].reshape(-1, c, h, w)\\n lqs_2 = lqs[:, 1:, :, :, :].reshape(-1, c, h, w)\\n flows_backward = self.spynet(lqs_1, lqs_2).view(n, t - 1, 2, h, w)\\n if self.is_mirror_extended:\\n flows_forward = None\\n else:\\n flows_forward = self.spynet(lqs_2, lqs_1).view(n, t - 1, 2, h, w)\\n return flows_forward, flows_backward\",\n \"def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\\n demand: float,\\n routing: np.ndarray) -> np.ndarray:\\n edge_mapping = {edge: i for i, edge in\\n enumerate(sorted(self.graph.edges))}\\n\\n link_utilisation = np.zeros(self.num_edges)\\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\\n node_flow[flow[0]] = demand\\n\\n to_explore = [flow[0]]\\n while to_explore:\\n current_node = to_explore.pop(0)\\n current_flow = node_flow[current_node]\\n\\n # this is the flow destination node so we absorb all flow\\n if current_node == flow[1]:\\n node_flow[current_node] = 0.0\\n continue\\n\\n # push the flow at this node over all edges\\n for edge in self.graph.out_edges(current_node):\\n edge_index = edge_mapping[edge]\\n ratio = routing[edge_index]\\n flow_to_send = ratio * current_flow\\n # only send flow if greater than epsilon (so no 'infinite' loops)\\n if flow_to_send > 1.e-8:\\n node_flow[edge[1]] += ratio * current_flow\\n # all important step, update our output\\n link_utilisation[edge_index] += ratio * current_flow\\n # have updated the dst so add it to the list of things to do\\n to_explore.append(edge[1])\\n # we've moved all the flow from this node now, so reset back to zero\\n node_flow[current_node] = 0.0\\n\\n return link_utilisation\",\n \"def DRBFS(self, flow, edge_mark):\\n\\t\\t# Distance flag for each node\\n\\t\\td = {v:float('inf') for v in self.topo.nodes}\\n\\t\\t# Parent node for each node\\n\\t\\tpa = {v:-1 for v in self.topo.nodes}\\n\\t\\t# Request info\\n\\t\\ts = flow[0]\\n\\t\\tt = flow[1]\\n\\n\\t\\t# BFS to find a min-hop path\\n\\t\\tqueue = [s]; hdr = 0; d[s] = 0\\n\\t\\twhile hdr < len(queue):\\n\\t\\t\\tu = queue[hdr]\\n\\t\\t\\thdr += 1\\n\\n\\t\\t\\tfor v in self.topo.topo.neighbors(u):\\n\\t\\t\\t\\tif edge_mark[(u, v)] or d[v] <= d[u] + 1:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tqueue.append(v)\\n\\t\\t\\t\\td[v] = d[u] + 1\\n\\t\\t\\t\\tpa[v] = u\\n\\t\\t\\t\\tif v == t:\\n\\t\\t\\t\\t\\t# This is because when BFS on edges, the first time reaching t meaning the smallest hop it can be reached\\n\\t\\t\\t\\t\\thdr = len(queue)\\n\\t\\t\\t\\t\\tbreak\\n\\n\\t\\tif d[t] == float('inf'):\\n\\t\\t\\treturn False\\n\\n\\t\\tp = [t]; v = t\\n\\t\\twhile v != s and v != -1:\\n\\t\\t\\tv = pa[v]\\n\\t\\t\\tp.append(v)\\n\\t\\tp.reverse()\\n\\n\\t\\treturn p\",\n \"def get_all_sghop_info (nffg, return_paths=False):\\n sg_map = {}\\n for i in nffg.infras:\\n for p in i.ports:\\n for fr in p.flowrules:\\n # if fr.external:\\n # continue\\n if fr.id not in sg_map:\\n # The path is unordered!!\\n path_of_shop = []\\n flowclass = NFFGToolBox._extract_flowclass(fr.match.split(\\\";\\\"))\\n sg_map[fr.id] = [None, None, flowclass, fr.bandwidth, fr.delay]\\n # We have to find the BEGINNING of this flowrule sequence.\\n inbound_link = NFFGToolBox._find_infra_link(nffg, p, outbound=False,\\n accept_dyn=True)\\n while inbound_link.type != 'DYNAMIC':\\n path_of_shop.append(inbound_link)\\n if inbound_link.src.node.type == 'SAP':\\n break\\n # The link is STATIC, and its src is not SAP so it is an Infra.\\n prev_fr, prev_p = \\\\\\n NFFGToolBox._get_flowrule_and_its_starting_port(\\n inbound_link.src.node, fr.id)\\n NFFGToolBox._check_flow_consistencity(sg_map, prev_fr)\\n inbound_link = NFFGToolBox._find_infra_link(nffg, prev_p,\\n outbound=False,\\n accept_dyn=True)\\n # 'inbound_link' is DYNAMIC here or it is STATIC and starts from\\n # a SAP,\\n # so the sequence starts here\\n sg_map[fr.id][0] = inbound_link.src\\n\\n # We have to find the ENDING of this flowrule sequence.\\n output_port = NFFGToolBox._get_output_port_of_flowrule(i, fr)\\n if output_port is None:\\n continue\\n outbound_link = NFFGToolBox._find_infra_link(nffg, output_port,\\n outbound=True,\\n accept_dyn=True)\\n while outbound_link.type != 'DYNAMIC':\\n path_of_shop.append(outbound_link)\\n if outbound_link.dst.node.type == 'SAP':\\n break\\n # The link is STATIC and its dst is not a SAP so it is an Infra.\\n next_fr, _ = NFFGToolBox._get_flowrule_and_its_starting_port(\\n outbound_link.dst.node, fr.id)\\n # '_' is 'outbound_link.dst'\\n next_output_port = NFFGToolBox._get_output_port_of_flowrule(\\n outbound_link.dst.node, next_fr)\\n NFFGToolBox._check_flow_consistencity(sg_map, next_fr)\\n outbound_link = NFFGToolBox._find_infra_link(nffg,\\n next_output_port,\\n outbound=True,\\n accept_dyn=True)\\n # the 'outbound_link' is DYNAMIC here or finishes in a SAP, so the\\n # flowrule sequence finished here.\\n sg_map[fr.id][1] = outbound_link.dst\\n\\n if return_paths:\\n sg_map[fr.id].append(path_of_shop)\\n\\n return sg_map\",\n \"def routes_for_od(self, r, s):\\n\\n for path in self.paths_for_od(r, s):\\n route = self._road_network.network.copy()\\n\\n for edge in route.edges_iter():\\n u,v = edge\\n if BaseRouter._edge_in_path(path, edge):\\n route.edge[u][v]['pathweight'] = 0.1\\n else:\\n route.edge[u][v]['pathweight'] = 1.0\\n\\n # Set node weights\\n for node in route:\\n try:\\n dist_from_path = nx.shortest_path_length(route,\\n node,\\n path[-1],\\n weight='pathweight')\\n except nx.NetworkXNoPath:\\n dist_from_path = float('inf')\\n\\n route.node[node]['weight'] = math.exp(-self._beta*dist_from_path)\\n\\n \\n # Create policy from weights\\n def edge_weight(u,v):\\n return route.node[v]['weight']*math.exp(\\n -self._beta*route.edge[u][v]['pathweight'])\\n\\n for node in route:\\n edges = route.edges(node)\\n total_edge_weight = reduce(\\n lambda x,y: x+y,\\n [edge_weight(u,v) for u,v in edges],\\n 0.0)\\n\\n for u,v in edges:\\n route[u][v]['weight'] = \\\\\\n edge_weight(u, v) / float(total_edge_weight)\\n\\n yield Route(route, path)\",\n \"def dfs_r(self, s):\\n g = Graph(attr={DIRECTED: True})\\n return self.dfs_rec(g, ('#', s))\",\n \"def distribute(node, rank_links):\\n r = rank_links[0]\\n links = rank_links[1]\\n\\n ol = str(links).split('|')\\n Ni = len(ol)\\n\\n # if the node is for dangling (i.e. no outgoing link),\\n # emit the loss to redistribute to all the incoming\\n # links to the dangling node\\n if (Ni == 1 and ol[0] == '') or Ni == 0:\\n yield 'DANGLING', r\\n else:\\n r_new = float(r)/float(Ni)\\n for l in ol:\\n yield l, r_new\\n\\n # recover graph structure\\n if links <> '':\\n yield node, links\",\n \"def update_flow(self):\\n start_nodes = []\\n end_nodes = []\\n capacities = []\\n # (1): add all edges (u, v) with capacity ub-lb\\n B = self.get_max_lb()*(self.num_edges() - len(self) + 2)\\n for arc in self.arc_info.keys():\\n if self.arc_info[arc][\\\"upper_bound\\\"] == float('inf'):\\n self.arc_info[arc][\\\"upper_bound\\\"] = B\\n for arc in self.arc_info.keys():\\n start_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n capacities.append(int(self.arc_info[arc][\\\"upper_bound\\\"]\\\\\\n - self.arc_info[arc][\\\"lower_bound\\\"]))\\n # (2): add edge (t, s) with capacity B\\n # B = max_lb * (m - n + 2)\\n B = self.get_max_lb()*(self.num_edges() - len(self) + 2)\\n if B == 0:\\n #B = float('inf')\\n B = 100000\\n start_nodes.append(self.sink())\\n end_nodes.append(self.source())\\n capacities.append(int(B))\\n # (3): for all verts, if exc > 0, add edge (s', v) with capacity exc(v),\\n # and if exc < 0, add edge(s', v) with capacity -exc(v)\\n s_prime = max(self.vertices) + 1\\n t_prime = max(self.vertices) + 2\\n print(\\\"s'={}, t'={}\\\".format(s_prime, t_prime))\\n for v in self:\\n #print(\\\"vert {} in arcs: {}\\\".format(v,\\n # self.in_arcs_lists[v]))\\n # compute exc: lower bounds of in - lower bounds of out\\n sum_lb_in = 0\\n for in_arc in self.in_arcs_lists[v]:\\n sum_lb_in += self.arc_info[in_arc][\\\"lower_bound\\\"]\\n sum_lb_out = 0\\n #print(\\\"vert {} out arcs: {}\\\".format(v,\\n # self.out_arcs_lists[v]))\\n for out_arc in self.out_arcs_lists[v]:\\n sum_lb_out += self.arc_info[out_arc][\\\"lower_bound\\\"]\\n exc = sum_lb_in - sum_lb_out\\n #print(\\\"exc is {}\\\".format(exc))\\n if exc > 0:\\n start_nodes.append(s_prime)\\n end_nodes.append(v)\\n capacities.append(int(exc))\\n else:\\n start_nodes.append(v)\\n end_nodes.append(t_prime)\\n capacities.append(int(-exc))\\n # solve maxflow\\n #print(\\\"s' is {} and t' is {}\\\".format(s_prime, t_prime))\\n max_flow = pywrapgraph.SimpleMaxFlow()\\n for u, v, cap in zip(start_nodes, end_nodes, capacities):\\n #print(\\\"Adding edge {}, {} with cap {}\\\".format(u,v,cap))\\n max_flow.AddArcWithCapacity(u, v, cap)\\n success = True\\n if max_flow.Solve(s_prime, t_prime) == max_flow.OPTIMAL:\\n #print('Max flow: {}'.format( max_flow.OptimalFlow()))\\n #print(' Arc Flow / Capacity')\\n for i in range(max_flow.NumArcs()):\\n # print('%1s -> %1s %3s / %3s' % (\\n # max_flow.Tail(i),\\n # max_flow.Head(i),\\n # max_flow.Flow(i),\\n # max_flow.Capacity(i)))\\n # check that (s', v) edges are saturated (once we find a false,\\n # stay false forever)\\n if success:\\n if max_flow.Tail(i) == s_prime:\\n success = max_flow.Flow(i) == max_flow.Capacity(i)\\n else:\\n success = False\\n print('There was an issue with the max flow input.')\\n if success:\\n # update the flows to be the flow found from maxflow problem\\n for i in range(max_flow.NumArcs()):\\n # if this is an original arc, update the flow\\n if max_flow.Tail(i) != s_prime \\\\\\n and max_flow.Head(i) != t_prime \\\\\\n and not (max_flow.Tail(i) == self.sink() \\\\\\n and max_flow.Head(i) == self.source()):\\n # update arc\\n start = max_flow.Tail(i)\\n destin = max_flow.Head(i)\\n arc = self.get_arc(start, destin)\\n new_flow = self.arc_info[arc][\\\"lower_bound\\\"] + max_flow.Flow(i)\\n old_flow = self.arc_info[arc][\\\"weight\\\"]\\n self.arc_info[arc][\\\"weight\\\"] = new_flow\\n #print(\\\"Edge {} {} adjusted from {} to {}\\\".format(\\n # start,\\n # destin,\\n # old_flow,\\n # new_flow\\n # ))\\n self.check_conservation_of_flow() # check that solution is valid\\n return True\\n else:\\n return False\",\n \"def findPathsToBase(A,bSize):\\n M,N = A.shape\\n pressedPaths = []\\n\\n #For every two nodes in the base find all paths between them\\n for b1 in range(bSize):\\n for b2 in range(bSize):\\n #Remove all other base nodes from the graph so that\\n #we only find paths that go through the specialization set\\n if b1 == b2:\\n #In this case we are looking for a cycle.\\n mask = [b1]+list(range(bSize,N))\\n newSize = len(mask) + 1\\n reduA = np.zeros((newSize,newSize))\\n #Because the networkx cycle finders don't do what we need\\n #them to do, we create a new graph and find paths instead\\n reduA[:-1,:-1] = A[mask,:][:,mask]\\n #Remove ingoing edges from the base node and add to new node\\n reduA[-1,:] = reduA[0,:]\\n reduA[0,:] = np.zeros(newSize)\\n G = nx.DiGraph(reduA.T)\\n #Find paths from the base node to the new node\\n #same as finding all the cycles\\n paths = list(nx.all_simple_paths(G,0,newSize-1))\\n\\n else:\\n mask = [b1,b2]+list(range(bSize,N))\\n reduA = A[mask,:][:,mask]\\n #Remove base node interactions\\n reduA[:2,:2] = np.zeros((2,2))\\n G = nx.DiGraph(reduA.T)\\n paths = list(nx.all_simple_paths(G,0,1))\\n\\n #Process Paths so that they make sense when the rest of the base\\n #set is added to the graph\\n for p in paths:\\n if p != []:\\n if b1 == b2:\\n p = np.array(p) + bSize-1\\n else:\\n p = np.array(p) + bSize-2\\n p[[0,-1]] = [b1, b2]\\n pressedPaths.append(p)\\n\\n return pressedPaths\",\n \"def compute_half_life_vested_shares(params, step, sL, s, inputs):\\n key = 'delegators'\\n \\n delegators = s['delegators']\\n\\n half_life_vesting_rate = params['half_life_vesting_rate']\\n \\n for delegator in delegators.values():\\n # for future computation speed, vest them in chunks, it doesn't matter which chunk\\n shares_vesting_this_period = delegator.unvested_shares * half_life_vesting_rate\\n for timestep in delegator._unvested_shares:\\n remaining_shares_to_vest = shares_vesting_this_period\\n if delegator._unvested_shares[timestep] > remaining_shares_to_vest:\\n delegator._unvested_shares[timestep] -= remaining_shares_to_vest\\n break\\n else:\\n # 0 out and go onto the next one\\n remaining_shares_to_vest -= delegator._unvested_shares[timestep]\\n delegator._unvested_shares[timestep] = 0\\n \\n delegator.vested_shares += shares_vesting_this_period\\n # print(f'{delegator.vested_shares=}, {delegator.unvested_shares=}, {delegator.shares=}')\\n value = delegators\\n\\n return key, value\",\n \"def dfs_traversal(graph, s, goals=[]):\\n visited = []\\n boundary = [s]\\n while len(boundary) > 0:\\n v = boundary.pop()\\n visited += [v]\\n if v in goals:\\n return visited\\n for w in neighbours(v, graph):\\n if w not in visited and w not in boundary:\\n boundary.append(w)\\n return visited\\n\\n \\\"\\\"\\\"\\n visited = []\\n boundary = [s]\\n while len(boundary) > 0:\\n v = boundary.pop()\\n visited += [v]\\n for w in neighbours(v, graph):\\n if w not in visited and w not in boundary:\\n boundary.append(w)\\n if w in goals:\\n v = boundary.pop()\\n visited += [v]\\n return visited\\n\\\"\\\"\\\"\",\n \"def get_dfs(self, s):\\n results = []\\n # mark all the vertices as not visited\\n visited = [False] * (len(self.graph))\\n self._dfs_recursive(s, visited, results)\\n return results\",\n \"def bfs(g: nx.Graph, start_node: Hashable) -> List[Hashable]:\\n list_ = list(g.neighbors(start_node))\\n len_graph = g.number_of_nodes()\\n list2 = [start_node]\\n while len(list2) < len_graph:\\n for i in range(len(list_) - 1):\\n if list_[0] not in list2:\\n list2.append(list_[0])\\n list_ += list(g.neighbors(list_[0]))\\n list_.remove(list_[0])\\n # nx.draw(g, with_labels=True)\\n # plt.show()\\n return list2\",\n \"def flowingFrom(self, fount):\",\n \"def hmn2(a, s, m0):\\n n = 2*m0**s\\n links = np.zeros((int(a/m0*n*sum([1/2**x for x in range(1, s+1)])), 2), dtype=np.int32)\\n links_i = 0\\n p = 0\\n \\n # At each hierarchy level a number of a links are established,\\n # repeating the process if links are repeated.\\n for si in range(1, s+1):\\n m0_si = m0**si\\n for n in range(0, n+1-2*m0_si, 2*m0_si):\\n \\n if a == 1:\\n i = np.random.randint(0 + n, m0_si + n)\\n j = np.random.randint(m0_si + n, 2*m0_si + n)\\n links[p] = np.array([i, j])\\n p += 1\\n \\n else:\\n while len(np.unique(links[links_i:a + links_i], axis=0)) != a:\\n for m in range(a):\\n i = np.random.randint(0 + n, m0_si + n)\\n j = np.random.randint(m0_si + n, 2*m0_si + n)\\n links[links_i:a + links_i][m] = np.array([i, j])\\n links_i += a\\n \\n blocks = np.arange(n).reshape((int(n/m0), m0))\\n return np.concatenate((blocks, links))\",\n \"def destination_floors(self):\\r\\n return self.destinations\",\n \"def compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\\n logger.debug(f\\\"comparing {node1},{node2}, traversed {traversed}\\\")\\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\\n #remove dummies\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\\n #remove dummies\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\\n logger.debug(f\\\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\\\")\\n logger.debug(f\\\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\\\")\\n if not nbrs1 or not nbrs2:\\n if compare_two_nodes(G, node1, node2, ports_weight):\\n match_pair[node1] = node2\\n logger.debug(f\\\"no new neihbours, returning recursion {match_pair}\\\")\\n return\\n elif len(nbrs1)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node1} {nbrs1}\\\")\\n traversed.append(node1)\\n return\\n elif len(nbrs2)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n traversed.append(node2)\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node2} {nbrs2}\\\")\\n return\\n\\n if node1 == node2:\\n if node1 in match_pair.keys() or node1 in match_pair.values():\\n logger.debug(\\\"avoid existing pair wise symmetry\\\")\\n return\\n logger.debug(f\\\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\\\")\\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\\n ## TBD: filter based on primitive constraints\\n ## Right now will try to figure out S/D paths\\n if len(SD_nbrs) ==0:\\n logger.debug(f\\\"No SD paths found to traverse\\\")\\n match_pair[node1]=node1\\n elif len(SD_nbrs) ==1:\\n logger.debug(f\\\"traversing single S/D path {SD_nbrs}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\\n else:\\n logger.debug(f\\\" multiple nodes diverging {SD_nbrs}\\\")\\n logger.debug(f\\\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n new_sp=sorted(set(SD_nbrs)-set(traversed))\\n all_match_pairs_local={}\\n for nbr1,nbr2 in combinations(new_sp, 2):\\n logger.debug(f\\\"recursive pair call from single branch {nbr1} {nbr2}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n if new_pair:\\n #new_pair[nbr1]=nbr2\\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\\n if len(all_match_pairs_local)==1:\\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\\n logger.debug(f\\\"found inline pair: {pprint.pformat(match_pair, indent=4)}\\\")\\n else:\\n for nbr1 in new_sp:\\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\\n logger.debug(f\\\"recursive single branch call from single branch {nbr1} {nbr1}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif nbrs1 == nbrs2:\\n logger.debug(f\\\"traversing converging branch\\\")\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\\n logger.debug(f\\\"all non traversed neighbours: {nbrs1}\\\")\\n if len(nbrs1)==1:\\n nbr1=nbr2=nbrs1[0]\\n logger.debug(f\\\"keeping single converged branch inline {nbr1} {nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n else:\\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\\n logger.debug(f\\\"recursive call from converged branch {nbr1} {nbr2}\\\")\\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif compare_two_nodes(G,node1,node2,ports_weight):\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n logger.debug(f\\\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\\\")\\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\\n if len(nbrs1)==0 or len(nbrs2)==0:\\n logger.debug(f\\\"no new SD neihbours, returning recursion {match_pair}\\\")\\n elif len(nbrs1) ==1 and len(nbrs2)==1:\\n logger.debug(f\\\"traversing binary branch\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\\n elif unique_match:\\n logger.debug(f'traversing unique matches {unique_match}')\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n for nbr1,nbr2 in unique_match.items():\\n logger.debug(f\\\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\\n logger.debug(f\\\"setting new start points {node1} {node2}\\\")\\n match_pair[node1]=node2\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end all traversal from binary branch {node1} {node2}\\\")\\n\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end of recursion branch, matches {match_pair}\\\")\",\n \"def enumerate_links_around_node(self, node):\\n\\n l0 = self.node_link[node]\\n l = l0\\n edges = []\\n traversing = True\\n while traversing:\\n edges.append(l)\\n v = l[0]\\n if v == node:\\n l = self.pred_right[l]\\n else:\\n l = self.pred_left[l]\\n if l0 == l:\\n traversing = False\\n if l0[1] == l[0] and l0[0] == l[1]:\\n traversing = False\\n #print v, l\\n #raw_input('here')\\n return edges\",\n \"def directed_dfs(digraph, start, end, max_total_dist, max_dist_outdoors):\\n\\n\\n path = [[],0 , 0]\\n best_path = get_best_path(digraph, start, end, path, max_dist_outdoors, max_total_dist, best_path = None)\\n\\n if best_path[0] is None:\\n raise ValueError('No work')\\n else :\\n return best_path[0]\",\n \"def conversion(data_path, nodes, simtime, resolution=1):\\r\\n\\r\\n receivers = set() # i.e. neurons; senders can be external inputs\\r\\n edges_set = set()\\r\\n\\r\\n # Ask number of neurons per node\\r\\n nodes_dict = dict()\\r\\n if input(\\\"Every node has same number of neurons? (y/n)\\\") == \\\"y\\\":\\r\\n n = int(input(\\\"Number of neurons per node: \\\"))\\r\\n for node in range(nodes):\\r\\n nodes_dict[node] = n\\r\\n receivers.update([str(node) + \\\"-\\\" + str(neuron) for neuron in range(nodes_dict[node])])\\r\\n else:\\r\\n for node in range(nodes):\\r\\n nodes_dict[node] = int(input(\\\"Number of neurons in node %s: \\\" % node))\\r\\n receivers.update([str(node) + \\\"-\\\" + str(neuron) for neuron in range(nodes_dict[node])])\\r\\n\\r\\n receivers = sorted(list(receivers))\\r\\n\\r\\n # Load a part of FNS data to gather information about edges\\r\\n df = pd.read_csv(data_path, header=None, usecols=[0, 1, 2, 3, 4, 5], chunksize=500000, nrows=2000000)\\r\\n for chunk in df:\\r\\n chunk.columns = [\\\"Burning Time\\\", \\\"Firing Node\\\", \\\"Firing Neuron\\\", \\\"Burning Node\\\", \\\"Burning Neuron\\\",\\r\\n \\\"External Source\\\"]\\r\\n print(chunk.index)\\r\\n for node in range(nodes):\\r\\n temp = chunk.loc[\\r\\n (chunk[\\\"Burning Node\\\"] == node) & (chunk[\\\"External Source\\\"] == False)] # Remove external inputs\\r\\n for i in range(len(temp)):\\r\\n print(\\\"Gathering edge information for node: %i/%i. Connection: %i/%i\\\" % (\\r\\n node + 1, nodes, i + 1, len(temp)), end=\\\"\\\\r\\\")\\r\\n sender = str(np.asarray(temp[\\\"Firing Node\\\"])[i]) + \\\"-\\\" + str(np.asarray(temp[\\\"Firing Neuron\\\"])[i])\\r\\n receiver = str(node) + \\\"-\\\" + str(np.asarray(temp[\\\"Burning Neuron\\\"])[i])\\r\\n edges_set.add((sender, receiver))\\r\\n print(\\\"Gathering edge information for node: %i/%i. Connection: %i/%i\\\" % (node + 1, nodes, i + 1, len(temp)))\\r\\n\\r\\n status_table = pd.DataFrame(np.zeros((len(receivers), len(range((simtime - 1) * resolution)))),\\r\\n columns=list(range((simtime - 1) * resolution)), index=receivers)\\r\\n\\r\\n df = pd.read_csv(data_path, header=None, usecols=[0, 1, 2, 3, 4, 5], chunksize=1000000)\\r\\n for chunk in df:\\r\\n chunk.columns = [\\\"Burning Time\\\", \\\"Firing Node\\\", \\\"Firing Neuron\\\", \\\"Burning Node\\\", \\\"Burning Neuron\\\",\\r\\n \\\"External Source\\\"]\\r\\n print(chunk.index)\\r\\n\\r\\n # Loop over times instead of receivers: slightly better efficiency for large datasets\\r\\n times_raw = sorted(set(chunk[\\\"Burning Time\\\"]))\\r\\n status_table_temp = pd.DataFrame(columns=receivers)\\r\\n status_table_aux = pd.DataFrame(np.zeros((len(receivers), len(range((simtime - 1) * resolution)))),\\r\\n columns=list(range((simtime - 1) * resolution)), index=receivers)\\r\\n\\r\\n times = list(np.arange(0, int(max(times_raw) + 1), 1 / resolution))\\r\\n min_t = int(np.trunc(min(chunk[\\\"Burning Time\\\"])))\\r\\n max_t = int(np.trunc(max(chunk[\\\"Burning Time\\\"])))\\r\\n\\r\\n for t in times[min_t:max_t]:\\r\\n print(\\\"Gathering nodes' activity dynamics - t: %i/%i\\\" % (t + 1, max_t), end=\\\"\\\\r\\\")\\r\\n temp = chunk.loc[np.trunc(chunk[\\\"Burning Time\\\"]) == t, (\\\"Burning Node\\\", \\\"Burning Neuron\\\")]\\r\\n # Count burning events for each neuron at time t\\r\\n count = Counter([str(node) + \\\"-\\\" + str(neuron) for node, neuron in np.asarray(temp)])\\r\\n # Every time step we add a Counter dict to fill status table\\r\\n status_table_temp = status_table_temp.append(count, ignore_index=True)\\r\\n print(\\\"Gathering nodes' activity dynamics - t: %i/%i\\\" % (t + 1, max_t))\\r\\n\\r\\n # status_table_temp contains just a limited space of time each chunk\\r\\n status_table_temp = status_table_temp.transpose()\\r\\n status_table_temp.columns = list(\\r\\n np.arange(start=int(np.trunc(min(chunk[\\\"Burning Time\\\"]))), stop=int(np.trunc(max(chunk[\\\"Burning Time\\\"])))))\\r\\n status_table_temp = status_table_temp.fillna(0)\\r\\n\\r\\n # status_table_aux contains all time steps with temp table values and 0s for the rest each chunk\\r\\n status_table_aux = status_table_aux.add(status_table_temp)\\r\\n status_table_aux = status_table_aux.fillna(0)\\r\\n\\r\\n # status_table merges all chunks' data\\r\\n status_table = status_table.add(status_table_aux)\\r\\n status_table = status_table.fillna(0)\\r\\n\\r\\n timestamp = datetime.now()\\r\\n new_dir = \\\"gephiFiles\\\" + timestamp.strftime(\\\"d%d_%m_%Y-t%H_%M_%S\\\")\\r\\n os.mkdir(new_dir)\\r\\n\\r\\n # Generate gephi compliant files\\r\\n t = \\\"<\\\" + str(times) + \\\">\\\"\\r\\n gephi_nodes = pd.DataFrame(columns=[\\\"id\\\", \\\"label\\\", \\\"timeset\\\", \\\"events\\\", \\\"node\\\"])\\r\\n for idx, node in enumerate(receivers):\\r\\n print(\\\"Writing nodes' file for Gephi: %i/%i\\\" % (idx, len(receivers)), end=\\\"\\\\r\\\")\\r\\n events_row = [[float(i), int(events)] for i, events in enumerate(status_table.loc[node])]\\r\\n events_row = str(events_row).replace(\\\"[[\\\", \\\"<[\\\").replace(\\\"]]\\\", \\\"]>\\\").replace(\\\"],\\\", \\\"];\\\")\\r\\n new_row = pd.Series([node, node, t, events_row, node.split(\\\"-\\\")[0]], index=gephi_nodes.columns)\\r\\n gephi_nodes = gephi_nodes.append(new_row, ignore_index=True)\\r\\n print(\\\"Writing nodes' file for Gephi: %i/%i\\\" % (idx, len(receivers)))\\r\\n gephi_nodes.to_csv(new_dir + \\\"/gephi_nodes.csv\\\", index=False)\\r\\n\\r\\n print(\\\"Compute gephi files with %i edges will last %0.2fm approx.\\\" % (len(edges_set), len(edges_set) / 12000))\\r\\n if input(\\\"Do you want to proceed? (y/n) \\\") == \\\"n\\\":\\r\\n exit()\\r\\n gephi_edges = pd.DataFrame(columns=[\\\"Source\\\", \\\"Target\\\", \\\"type\\\", \\\"id\\\", \\\"weight\\\"])\\r\\n for idx, edge in enumerate(edges_set):\\r\\n print(\\\"Writing edges' file for Gephi: %i/%i\\\" % (idx, len(edges_set)), end=\\\"\\\\r\\\")\\r\\n edge_row = pd.Series([edge[0], edge[1], \\\"Directed\\\", idx, 1], index=gephi_edges.columns)\\r\\n gephi_edges = gephi_edges.append(edge_row, ignore_index=True)\\r\\n print(\\\"Writing edges' file for Gephi: %i/%i\\\" % (idx, len(edges_set)))\\r\\n gephi_edges.to_csv(new_dir + \\\"/gephi_edges.csv\\\", index=False)\\r\\n\\r\\n return None\",\n \"def ssf(n, N_max = 6, E_max = 4, time_total = 100 ):\\n\\n G = nx.DiGraph()\\n G.add_edge( 0, 1, time_stamp = 1)\\n\\n # List of existing nodes, with nodes repeated once for each adjacent edge\\n repeated_nodes = [0, 1]\\n\\n # compute discrete bins for nodes \\n DistNodes = _get_distribution( N_max, 0 )\\n # compute discrete bins for edges\\n DistLinks = _get_distribution( E_max, 1 )\\n \\n # Start adding the other n - 2 nodes.\\n N_current = time_current = 2\\n while N_current < n and time_current < time_total + 1:\\n # preferential attachment\\n N_current = _preferential_attachment( DistNodes, DistLinks, N_current,\\n time_total, time_current, n, repeated_nodes, G )\\n time_current += 1\\n \\n# print(time_current, N_current)\\n return G\",\n \"def calc_overall_link_utilisation(self, demands: Demand,\\n routing: Routing) -> np.ndarray:\\n flows = [(i, j) for i in range(self.num_nodes)\\n for j in range(self.num_nodes)\\n if i != j]\\n\\n link_utilisation = np.zeros(self.num_edges)\\n\\n for i, flow in enumerate(flows):\\n flow_link_utilisation = self.calc_per_flow_link_utilisation(flow,\\n demands[\\n i],\\n routing[\\n i])\\n link_utilisation += flow_link_utilisation\\n\\n return link_utilisation\",\n \"def hmn1(a, p, s, m0):\\n n = 2*m0**s\\n links = np.zeros((2*int(a/m0*n*sum([1/2**x for x in range(1, s+1)])), 2), dtype=np.int32)\\n\\n links_i = 0\\n for si in range(1, s+1):\\n # 2 Blocks at the same level get linked with\\n # a shrinking probability with rising level.\\n m0_si = m0**si\\n for n in range(0, n+1-2*m0_si, 2*m0_si):\\n # Connection ensures that at the end of each\\n # linking process, at least one link between\\n # blocks at the same level exists.\\n m0_si_n = m0_si + n\\n connection = 0\\n while connection == 0:\\n for link1 in range(n, m0_si_n):\\n for link2 in range(m0_si_n, 2*m0_si+n): \\n if np.random.rand() < a*p**si:\\n links[links_i] = [link1, link2]\\n links_i += 1\\n connection = 1\\n \\n # Creates the links in the blocks and removes empty\\n # placeholders in links.\\n blocks = np.arange(n).reshape((int(n/m0), m0))\\n links = np.trim_zeros(links.ravel(), 'b').reshape((links_i, 2))\\n\\n return np.concatenate((blocks, links))\",\n \"def get_flows(self, x):\\n if self.pa_frames == 2:\\n flows_backward, flows_forward = self.get_flow_2frames(x)\\n elif self.pa_frames == 4:\\n flows_backward_2frames, flows_forward_2frames = self.get_flow_2frames(x)\\n flows_backward_4frames, flows_forward_4frames = self.get_flow_4frames(flows_forward_2frames, flows_backward_2frames)\\n flows_backward = flows_backward_2frames + flows_backward_4frames\\n flows_forward = flows_forward_2frames + flows_forward_4frames\\n elif self.pa_frames == 6:\\n flows_backward_2frames, flows_forward_2frames = self.get_flow_2frames(x)\\n flows_backward_4frames, flows_forward_4frames = self.get_flow_4frames(flows_forward_2frames, flows_backward_2frames)\\n flows_backward_6frames, flows_forward_6frames = self.get_flow_6frames(flows_forward_2frames, flows_backward_2frames, flows_forward_4frames, flows_backward_4frames)\\n flows_backward = flows_backward_2frames + flows_backward_4frames + flows_backward_6frames\\n flows_forward = flows_forward_2frames + flows_forward_4frames + flows_forward_6frames\\n return flows_backward, flows_forward\",\n \"def BellmanFord(t):\\n\\n\\td = [float('inf') for i in nodes]\\t# Shortest distance to t\\n\\tn = [-1 for i in nodes]\\t\\t\\t# Next hop toward t\\n\\td[t] = 0\\n\\tfor i in range(len(nodes)-1):\\n\\t\\tfor j,(u,v) in enumerate(links):\\n\\t\\t\\tif d[u] > d[v] + length[j]:\\n\\t\\t\\t\\td[u] = d[v] + length[j] \\n\\t\\t\\t\\tn[u] = v\\n\\treturn n,d\",\n \"def separate_simulations(ns, ps, rs, savename, verbose=True):\\n #TODO: find bug that occasionally does not find the shortest path\\n if verbose:\\n\\n for n, p, r in zip(ns, ps, rs):\\n \\n print('n-{}, p-{}, r-{}'.format(n, p, r))\\n \\n rand_points = np.random.uniform(size=(2, n-2))\\n edge_points = np.array([[0.0, 1.0],[0.0, 1.0]])\\n points = np.concatenate((rand_points, edge_points), axis=1)\\n \\n print('Generated points.', end = '')\\n \\n connections = get_connections(points, pval=p, radius=r)\\n\\n print('Got connections.')\\n \\n print('Getting paths.', end = '...')\\n \\n print('Longest.', end = '...')\\n long_pathBool, long_lengthBool = longest_path(connections.astype(bool))\\n long_path, long_length = longest_path(connections)\\n\\n print('Shortest.', end = '...')\\n short_pathBool, short_lengthBool = shortest_path(connections.astype(bool))\\n short_path, short_length = shortest_path(connections)\\n\\n short_pathBoolpoints, long_pathBoolpoints, short_pathpoints, long_pathpoints = [[list(points[:, u]) for u in indexes] for indexes in [short_pathBool, long_pathBool, short_path, long_path]]\\n\\n print('Saving file -> ' + savename)\\n file1 = open(savename,\\\"a\\\") \\n\\n file1.writelines('{} - {} - {} - {} - {} - {} - {} - {} - {} - {} - {}\\\\n'.format(p, r, n, short_lengthBool, long_lengthBool, short_length, long_length, short_pathBoolpoints, long_pathBoolpoints, short_pathpoints, long_pathpoints))\\n file1.close()\\n \\n else:\\n\\n for n, p, s in zip(ns, ps, rs):\\n\\n rand_points = np.random.uniform(size=(2, n-2))\\n edge_points = np.array([[0.0, 1.0],[0.0, 1.0]])\\n points = np.concatenate((rand_points, edge_points), axis=1)\\n\\n connections = get_connections(points, pval=p, radius=r)\\n\\n long_pathBool, long_lengthBool = longest_path(connections.astype(bool))\\n long_path, long_length = longest_path(connections)\\n\\n short_pathBool, short_lengthBool = shortest_path(connections.astype(bool))\\n short_path, short_length = shortest_path(connections)\\n\\n short_pathBoolpoints, long_pathBoolpoints, short_pathpoints, long_pathpoints = [[list(points[:, u]) for u in indexes] for indexes in [short_pathBool, long_pathBool, short_path, long_path]]\\n\\n file1 = open(savename,\\\"a\\\") \\n\\n file1.writelines('{} - {} - {} - {} - {} - {} - {} - {} - {} - {} - {}\\\\n'.format(p, r, n, short_lengthBool, long_lengthBool, short_length, long_length, short_pathBoolpoints, long_pathBoolpoints, short_pathpoints, long_pathpoints))\\n file1.close()\\n \\n return True\",\n \"def get_bipartition(g):\\n # Write your code here.\\n colorArr = [-1] * (len(g.nodes()) + 1)\\n for node in g.nodes():\\n start = g.neighbors(node)\\n if len(start)>0:\\n src = start.pop()\\n break\\n colorArr[src] = 1\\n queue = []\\n queue.append(src)\\n while (queue):\\n u = queue.pop()\\n for v in g.nodes():\\n if g.has_edge(u, v) and colorArr[v] == -1:\\n colorArr[v] = 1 - colorArr[u]\\n queue.append(v)\\n elif g.has_edge(u, v) and colorArr[u] == colorArr[v]:\\n return None\\n\\n red = set()\\n for i in range(1, len(colorArr)):\\n if colorArr[i] == 1:\\n red.add(i)\\n return list(red)\\n\\n\\n\\n # Hint! If you'd like to test out these commands without\\n # writing a full-fledged program, you might want to familiarise\\n # yourself with the Python interactive shell or IPython (available\\n # on at least some Aalto IT computers)\\n\\n # Create a simple line graph g: \\\"(1)->(2)->(3)\\\"\\n # (The creation parameter is a dict of {node: list_of_neighbors},\\n # but this is not something you will be needing in your code.)\\n # >>> from networkx import Graph \\n # >>> g = Graph({1: [2], 2: [3]})\\n # >>> g.number_of_nodes()\\n # 3\\n\\n # Example. Iterate over the nodes and mark them as visited\\n # >>> visited = set()\\n # >>> for node in g.nodes_iter(): # There is also g.nodes(), which returns a list\\n # ... # do some work here\\n # ... visited.add(node)\\n \\n # Example. Given a Node v, get all nodes s.t. there is an edge between\\n # v and that node\\n # >>> g.neighbors(1)\\n # [2]\\n\\n # Example. Get the edges of the graph:\\n # >>> e.edges() # as with nodes, there is also g.edges_iter()\\n # [(1, 2), (2, 3)]\\n\\n # For more information, consult the NetworkX documentation:\\n # https://networkx.github.io/documentation/networkx-1.10/tutorial/tutorial.html\",\n \"def get_path(self, sim, app_name, message, topology_src, alloc_DES, alloc_module, traffic, from_des):\\n node_src = topology_src\\n DES_dst = alloc_module[app_name][message.dst] # returns an array with all DES process serving\\n\\n if message.dst not in self.rr.keys():\\n self.rr[message.dst] = 0\\n\\n # print (\\\"GET PATH\\\")\\n # print (\\\"\\\\tNode _ src (id_topology): %i\\\" % node_src)\\n # print (\\\"\\\\tRequest service: %s \\\" % (message.dst))\\n # print (\\\"\\\\tProcess serving that service: %s (pos ID: %i)\\\" % (DES_dst, self.rr[message.dst]))\\n\\n bestPath = []\\n bestDES = []\\n\\n for ix, des in enumerate(DES_dst):\\n if message.name == \\\"RawVideo\\\" or message.name == \\\"IdentifyObject\\\":\\n if self.rr[message.dst] == ix:\\n dst_node = alloc_DES[des]\\n\\n path = list(nx.shortest_path(sim.topology.G, source=node_src, target=dst_node, weight='BW'))\\n\\n bestPath = [path]\\n bestDES = [des]\\n\\n self.rr[message.dst] = (self.rr[message.dst] + 1) % len(DES_dst)\\n break\\n else: # message.name == \\\"M.B\\\"\\n\\n dst_node = alloc_DES[des]\\n\\n path = list(nx.shortest_path(sim.topology.G, source=node_src, target=dst_node, weight='BW'))\\n if message.broadcasting:\\n bestPath.append(path)\\n bestDES.append(des)\\n else:\\n bestPath = [path]\\n bestDES = [des]\\n\\n return bestPath, bestDES\",\n \"def find_all_feedback_from_FVS(lt_links, ls_FVS=None):\\n if not ls_FVS:\\n set_nodes = set([])\\n for t_link in lt_links:\\n set_nodes.add(t_link[0])\\n set_nodes.add(t_link[1])\\n ls_FVS = FVS_analysis.FVS_finding(list(set_nodes), lt_links)[0]\\n #if FVS nodes are already gained, pass this step\\n \\n llt_feedbacks = []\\n dic_ts_FVSnodepair_llt_downstreams = {}#{(FVS node1, FVS node2):list of lt_downstream which starts at FVS node1 and ends at FVS node2}\\n for s_FVSnode in ls_FVS:\\n llt_downstreams = find_all_downstream_from_seed(lt_links, s_FVSnode, ls_FVS)\\n for lt_downstream in llt_downstreams:\\n ts_FVSpair = (s_FVSnode, lt_downstream[-1][-1])\\n dic_ts_FVSnodepair_llt_downstreams.setdefault(ts_FVSpair,[]).append(lt_downstream)\\n \\n lts_cyclesofFVS = get_all_cycles(ls_FVS)\\n for ts_cycleofFVS in lts_cyclesofFVS:\\n if len(ts_cycleofFVS) == 1:\\n llt_feedbacks.extend(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[0],ts_cycleofFVS[0])])\\n else:\\n b_stopflag = False\\n lllt_feedbackfragment = []\\n for i in range(len(ts_cycleofFVS)-1):\\n lllt_feedbackfragment.append(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[i], ts_cycleofFVS[i+1])])\\n if not dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[i], ts_cycleofFVS[i+1])]:\\n b_stopflag = True\\n break\\n lllt_feedbackfragment.append(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[-1],ts_cycleofFVS[0])])\\n if not dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[-1],ts_cycleofFVS[0])]:\\n b_stopflag = True\\n if b_stopflag:\\n continue#if there is no feedback passing by all FVS nodes of that cycle, pass to next cycle\\n \\n llt_feedbacks_specific_cycle = lllt_feedbackfragment.pop(0)\\n while lllt_feedbackfragment:\\n llt_fragments_next = lllt_feedbackfragment.pop(0)\\n llt_feedbacks_updated = []\\n for lt_fragment in llt_feedbacks_specific_cycle:\\n for lt_fragment_next in llt_fragments_next:\\n ls_route = [t_link[1] for t_link in lt_fragment[:-1]]\\n ls_route_next = [t_link[1] for t_link in lt_fragment_next[:-1]]\\n if not set(ls_route).intersection(set(ls_route_next)):\\n llt_feedbacks_updated.append(lt_fragment+lt_fragment_next)\\n llt_feedbacks_specific_cycle = llt_feedbacks_updated\\n llt_feedbacks.extend(llt_feedbacks_specific_cycle)\\n\\n return llt_feedbacks\",\n \"def test_get_dependencies_subgraph_by_dfs(\\n self, source_node, expected_nodes_in, expected_nodes_out\\n ):\\n graph = nx.DiGraph()\\n graph.add_node(\\\"pack1\\\")\\n graph.add_node(\\\"pack2\\\")\\n graph.add_node(\\\"pack3\\\")\\n graph.add_node(\\\"pack4\\\")\\n graph.add_edge(\\\"pack1\\\", \\\"pack2\\\")\\n graph.add_edge(\\\"pack2\\\", \\\"pack3\\\")\\n dfs_graph = PackDependencies.get_dependencies_subgraph_by_dfs(\\n graph, source_node\\n )\\n for i in expected_nodes_in:\\n assert i in dfs_graph.nodes()\\n for i in expected_nodes_out:\\n assert i not in dfs_graph.nodes()\",\n \"def find_sharpest_fork_general(Nodes):\\n pair_list = []\\n Dis = np.array([])\\n for n in Nodes:\\n if n.parent is not None:\\n if n.parent.parent is not None:\\n a = n.parent.children\\n if(isinstance(a, list)):\\n if(len(a)==2):\\n n1 = a[0]\\n n2 = a[1]\\n pair_list.append([n1 , n2])\\n dis = LA.norm(a[0].xyz - a[1].xyz,2)\\n Dis = np.append(Dis,dis)\\n if(len(Dis)!= 0):\\n (b,) = np.where(Dis == Dis.min())\\n sharpest_pair = pair_list[b[0]]\\n distance = Dis.min()\\n else:\\n sharpest_pair = [0,0]\\n distance = 0.\\n return sharpest_pair, distance\",\n \"def get_bfs(self, s):\\n # create a queue for BFS\\n queue = []\\n # mark all the vertices as not visited\\n visited = [False] * (len(self.graph))\\n # mark the start node as visited and enqueue it\\n visited[s] = True\\n queue.append(s)\\n results = []\\n\\n while queue:\\n # dequeue a vertex from queue and append to results.\\n p = queue.pop(0)\\n results.append(p)\\n # get all adjacent vertices of the dequeued vertex s,\\n # and for any unvisited adjacent, mark it visited and enqueue it.\\n for v in self.graph[p]:\\n if visited[v] is False:\\n visited[v] = True\\n queue.append(v)\\n\\n return results\",\n \"def sinks(self):\\n if self.rank < self.midpoint:\\n partner = self.midpoint + (self.rank - self.left)\\n if partner == self.right:\\n partner -= 1\\n else:\\n partner = self.left + (self.rank - self.midpoint)\\n if partner == self.midpoint:\\n partner -= 1\\n\\n return {partner}\",\n \"def bfs_traversal(graph, s, goals=[]):\\n visited = []\\n boundary = deque([s])\\n while len(boundary) > 0:\\n v = boundary.popleft()\\n visited += [v]\\n if v in goals:\\n return visited\\n for w in neighbours(v, graph):\\n if w not in visited and w not in boundary:\\n boundary.append(w)\\n return visited\\n\\n \\\"\\\"\\\"\\n visited = []\\n boundary = [s]\\n while len(boundary) > 0:\\n v = boundary.pop(0)\\n visited += [v]\\n for w in neighbours(v, graph):\\n if w not in goals:\\n if w not in visited and w not in boundary:\\n boundary.append(w)\\n else:\\n if w not in visited and w not in boundary:\\n boundary.append(w)\\n v = boundary.pop(0)\\n visited += [v]\\n break\\n return visited\\n \\\"\\\"\\\"\",\n \"def refugia_adj_5_simsplit(params, ns):\\n #20 parameters \\n nu1a, nu2a, nu3a, nu1b, nu2b, nu3b, m2_12, m2_13, m2_21, m2_23, m2_31, m2_32, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T2, T3 = params\\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\\n fs = moments.Spectrum(sts)\\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2]) \\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\\n ## Population function and migration matrix for T2\\n nu_T2 = [nu1a, nu2a, nu3a]\\n mig2 = numpy.array([[0, m2_12, m2_13],[m2_21, 0, m2_23], [m2_31, m2_32, 0]]) \\n fs.integrate(nu_T2, T2, m=mig2)\\n ## Population function and migration matrix for T3\\n nu_T3 = [nu1b, nu2b, nu3b]\\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \\n fs.integrate(nu_T3, T3, m=mig3) \\n return fs\",\n \"def dfs_edges_generator(graph, source, reverse=...):\\n ...\",\n \"def bfs_edges_generator(graph, source, reverse=...):\\n ...\",\n \"def bfs_path(graph, s, goals=[]):\\n visited = []\\n parents = [None]*len(graph)\\n boundary = [s]\\n while len(boundary) > 0:\\n v = boundary.pop(0)\\n visited += [v]\\n for w in neighbours(v, graph):\\n if w not in visited and w not in boundary:\\n boundary.append(w)\\n parents[w] = v\\n #w's parent\\n # put w's parent in the partent list\\n return get_path(parents, goals[0], goals[1])\",\n \"def _compute_longest_path_cut(self, src_uid, dst_uid):\\n # NOTE: at the time being the reason why it was chosen to include edges\\n # that belong to any path to the returned list, is unclear to me.\\n to_visit_uids = [dst_uid]\\n node_costs = {}\\n node_succs = {}\\n subgraph_edge_uids = []\\n subgraph_node_uids = [src_uid]\\n dsp = 0\\n\\n if (src_uid == dst_uid): # NOTE: deals with single-block graphs\\n node = self._nodes[src_uid]\\n return node.get_cost(), [src_uid], [], []\\n\\n # NOTE: the generated block graph might contain dead ends, thus\\n # visited_uids must be pre-computed\\n visited_uids = copy.deepcopy(self._nodes.keys())\\n lvisited_uids = []\\n while len(to_visit_uids) > 0:\\n cur_uid = to_visit_uids[0]\\n cur_node = self._nodes[cur_uid]\\n\\n if cur_uid in visited_uids:\\n visited_uids.remove(cur_uid)\\n\\n for pred_uid in cur_node.get_predecessors():\\n if pred_uid not in to_visit_uids and pred_uid not in lvisited_uids:\\n to_visit_uids.append(pred_uid)\\n\\n to_visit_uids = to_visit_uids[1:]\\n lvisited_uids.append(cur_uid)\\n\\n to_visit_uids = [dst_uid]\\n\\n # reverse graph exploration\\n while 0 < len(to_visit_uids):\\n assert(dsp < len(to_visit_uids))\\t# dead ends or loops\\n\\n cur_uid = to_visit_uids[dsp]\\n cur_node = self._nodes[cur_uid]\\n\\n assert(cur_uid != src_uid)\\n assert(cur_uid not in visited_uids)\\t# loop!\\n\\n # skip node for which there is still some unexplored successor\\n skip_uid = False\\n for succ_uid in cur_node.get_successors():\\n if not succ_uid in visited_uids:\\n skip_uid = True\\n\\n if skip_uid:\\n dsp += 1\\n continue\\n else:\\n dsp = 0\\n\\n if cur_uid == dst_uid:\\n node_costs[cur_uid] = cur_node.get_cost()\\n\\n for pred_uid in cur_node.get_predecessors():\\n pred_node = self._nodes[pred_uid]\\n # get edge pred_uid ---> cur_uid\\n edge_uid = Edge.get_edge_uid(pred_uid, cur_uid)\\n edge = self._edges[edge_uid]\\n edge_cost = edge.get_cost()\\n if edge_uid not in subgraph_edge_uids:\\n subgraph_edge_uids.append(edge_uid)\\n\\n # update node distance\\n pred_node_cost = node_costs[cur_uid] + edge_cost + pred_node.get_cost()\\n if pred_uid not in node_costs or pred_node_cost > node_costs[pred_uid]:\\n node_costs[pred_uid] = pred_node_cost\\n node_succs[pred_uid] = cur_uid\\n\\n # update to_visit_uids, a node cannot be visited more than once\\n if (pred_uid != src_uid) and (pred_uid not in visited_uids) \\\\\\n and (pred_uid not in to_visit_uids):\\n to_visit_uids.append(pred_uid)\\n\\n to_visit_uids.remove(cur_uid)\\n visited_uids.append(cur_uid)\\n subgraph_node_uids.append(cur_uid)\\n\\n # construct path from src_node to dst_node\\n cur_uid = src_uid\\n maxpath_node_uids = [cur_uid]\\n while cur_uid != dst_uid:\\n cur_uid = node_succs[cur_uid]\\n cur_node = self._nodes[cur_uid]\\n if cur_uid not in maxpath_node_uids:\\n maxpath_node_uids.append(cur_uid)\\n else:\\n raise Exception(\\\"invalid input source code graph: loop detected\\\")\\n\\n max_cost = node_costs[src_uid]\\n return max_cost, maxpath_node_uids, subgraph_node_uids, subgraph_edge_uids\",\n \"def _compute_paths_among(self, src_uid, dst_uid):\\n to_visit_uids = [dst_uid]\\n paths = {}\\n idx = 0\\n dsp = 0\\n\\n if (src_uid == dst_uid): # NOTE: deals with single-block graphs\\n return [src_uid]\\n\\n # NOTE: the generated block graph might contain dead ends, thus\\n # visited_uids must be pre-computed\\n visited_uids = copy.deepcopy(self._nodes.keys())\\n lvisited_uids = []\\n while len(to_visit_uids) > 0:\\n cur_uid = to_visit_uids[0]\\n cur_node = self._nodes[cur_uid]\\n\\n if cur_uid in visited_uids:\\n visited_uids.remove(cur_uid)\\n\\n for pred_uid in cur_node.get_predecessors():\\n if pred_uid not in to_visit_uids and pred_uid not in lvisited_uids:\\n to_visit_uids.append(pred_uid)\\n\\n to_visit_uids = to_visit_uids[1:]\\n lvisited_uids.append(cur_uid)\\n\\n to_visit_uids = [dst_uid]\\n\\n while idx < len(to_visit_uids):\\n assert(idx + dsp < len(to_visit_uids))\\n\\n cur_uid = to_visit_uids[idx + dsp]\\n cur_node = self._nodes[cur_uid]\\n\\n assert(cur_uid != src_uid)\\n assert(cur_uid not in visited_uids)\\n\\n # skip node for which there is still some unexplored successor\\n skip_uid = False\\n for succ_uid in cur_node.get_successors():\\n if succ_uid not in visited_uids:\\n skip_uid = True\\n\\n if skip_uid:\\n dsp += 1\\n continue\\n else:\\n dsp = 0\\n\\n if cur_uid == dst_uid:\\n paths[cur_uid] = 1\\n\\n for pred_uid in cur_node.get_predecessors():\\n if pred_uid not in paths:\\n paths[pred_uid] = paths[cur_uid]\\n else:\\n paths[pred_uid] += paths[cur_uid]\\n\\n # a node cannot be visited more than once\\n if pred_uid != src_uid and pred_uid not in visited_uids \\\\\\n and pred_uid not in to_visit_uids:\\n to_visit_uids.append(pred_uid)\\n\\n to_visit_uids.remove(cur_uid)\\n visited_uids.append(cur_uid)\\n\\n return paths[src_uid]\",\n \"def compute_path_hopping_flow_allocations(target_graph, K=3):\\n flow_allocation_seed_number = 0xCAFE_BABE\\n np.random.seed(flow_allocation_seed_number)\\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\\n link_utilization = {(u, v): 0.0 for u, v in target_graph.edges}\\n node_capacity = {u: 0.0 for u in target_graph.nodes}\\n flows = []\\n while True:\\n source_node, destination_node = flow_selection_fn(target_graph.nodes, 2, replace=False)\\n print(source_node, destination_node)\\n\\n shortest_paths = sorted(nx.all_simple_paths(target_graph, source_node, destination_node,\\n cutoff=3),\\n key=lambda p: len(p))\\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\\n\\n # flow_tx_rate = np.random.uniform() * 10\\n flow_tx_rate = 1.0\\n # if node_capacity[source_node] + flow_tx_rate > LINK_CAPACITY:\\n # break\\n node_capacity[source_node] += flow_tx_rate\\n capacity_was_exceeded = False \\n for path in [nx.utils.pairwise(p_i) for p_i in k_shortest_paths]:\\n for u, v in [sorted(h_i) for h_i in path]:\\n flow_rate_per_subpath = flow_tx_rate / K\\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\\n capacity_was_exceeded = True\\n break\\n link_utilization[u, v] += flow_rate_per_subpath\\n if capacity_was_exceeded:\\n break\\n\\n if capacity_was_exceeded:\\n break\\n\\n the_flow = Flow( source_node = source_node\\n , destination_node = destination_node\\n , flow_tx_rate = flow_tx_rate\\n , paths = k_shortest_paths\\n , splitting_ratio = [1.0/K]*K\\n )\\n flows.append(the_flow)\\n return flows, link_utilization\",\n \"def get_skims(G, transfer_penalty=300, delta=0.2):\\n # shortest path\\n sp = nx.shortest_path(G, weight='total_travel_time')\\n # create a dictionary for stop travel impedance values\\n # The travel impedance is also decomposed\\n # GTC: total generalized travel cost\\n # IVT: in-vehicle travel time\\n # NONIVT: the remaining part related to transfer and waiting times\\n ti = {}\\n fields = ['GTC', \\\"IVT\\\", \\\"WT\\\", \\\"TRANSFER\\\", \\\"NONIVT\\\"]\\n for key in sp.keys():\\n ti[key] = {}\\n for field in fields:\\n ti[key][field] = dict()\\n for source in sp.keys():\\n for target in sp[source].keys():\\n cur_sp = sp[source][target]\\n for field in fields:\\n ti[source][field][target] = 0\\n if not len(cur_sp) == 1:\\n # if not the node itself\\n for k in range(len(cur_sp) - 1):\\n i = cur_sp[k]\\n j = cur_sp[k + 1]\\n ti[source]['IVT'][target] += G[i][j]['ivt']\\n ti[source]['WT'][target] += G[i][j]['wt']\\n ti[source]['NONIVT'][target] += G[i][j]['wt']\\n ti[source]['NONIVT'][target] += (len(cur_sp) - 2) * transfer_penalty\\n ti[source]['TRANSFER'][target] = (len(cur_sp) - 2) * transfer_penalty\\n ti[source]['GTC'][target] = ti[source]['IVT'][target] + ti[source]['NONIVT'][target]\\n\\n skims = DotMap()\\n for field in fields:\\n skims[field] = pd.DataFrame([ti[i][field] for i in sp.keys()], index=sp.keys())\\n\\n x_list = list(nx.get_node_attributes(G, 'x').values())\\n y_list = list(nx.get_node_attributes(G, 'y').values())\\n df = pd.DataFrame({'node_id': list(sp.keys()), 'x': x_list, 'y': y_list})\\n df = df.set_index('node_id')\\n\\n skims['pos'] = df\\n return skims\",\n \"def get_routing_solution(self):\\n G = self.base_digraph\\n s1 = self.sources[0]\\n s2 = self.sources[1]\\n t1 = self.destinations[0]\\n t2 = self.destinations[1]\\n\\n try:\\n m = Model('routing')\\n m.setParam('OutputFlag', False)\\n\\n # variables,\\n # We have one variable per edge per session\\n # e is the dict of dict for the variables\\n e = {}\\n r = {}\\n for i in [1,2]:\\n e[i] = {}\\n r[i] = m.addVar()\\n for u,v in G.edges():\\n e[i][u,v] = m.addVar(lb=0)\\n\\n m.update()\\n\\n obj = quicksum(r.values())\\n m.setObjective(obj, GRB.MAXIMIZE)\\n\\n # constraints\\n # 1. conservations of flow at all intermediate nodes\\n # 2. capacity constraints for each edge\\n\\n for u,v in G.edges():\\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\\n\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\\n\\n for n in G.nodes():\\n if n not in [s1, s2, t1, t2]:\\n for i in [1, 2]:\\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\\n m.addConstr(inflow == outflow)\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n for u, v in G.edges():\\n G[u][v]['Routing'] = {}\\n G[u][v]['Routing'][1] = e[1][u,v].x\\n G[u][v]['Routing'][2] = e[2][u,v].x\\n return (m.objVal, r[1].x, r[2].x)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong, no optimal solution obtained\\\"\\n return None, None, None\\n\\n except GurobiError:\\n Print ('Error Report from Gurobi')\",\n \"def dfs_path(graph, s, goals=[]):\\n visited = []\\n parents = [None]*(len(graph))\\n boundary = [s]\\n while len(boundary) > 0:\\n v = boundary.pop()\\n visited += [v]\\n for w in neighbours(v, graph):\\n if w not in visited and w not in boundary:\\n boundary.append(w)\\n parents[w] = v\\n return get_path(parents, goals[0], goals[1])\",\n \"def caculate_network_statistics(self):\\n divide_factor_sum = 0 \\n for key in self.stars.keys():\\n star = self.stars[key]\\n if star.nb_num == 0 :\\n self.standalone_star_num += 1 \\n\\n divide_factor = star.nb_num + 2 * (star.spec_num - star.shared_spec_num )/self.ave_starlet_size\\n divide_factor_sum += divide_factor\\n divide_factor_int = round(divide_factor)\\n self.star_divide_factor_dist[divide_factor_int] = self.star_divide_factor_dist.get(divide_factor_int,0) + 1\\n if star.spec_num < star.shared_spec_num:\\n print(\\\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\\\")\\n print(\\\"with star \\\" + star.id + \\\" \\\" + str(star.spec_num) + \\\"is less than\\\" + str(star.shared_spec_num))\\n if star.spec_num > star.shared_spec_num:\\n self.star_lost_spec_num += star.spec_num - star.shared_spec_num\\n self.ave_divide_factor_star = divide_factor_sum/self.stars_length\\n\\n divide_factor_sum = 0 \\n for key in self.starlets.keys():\\n starlet = self.starlets[key]\\n if starlet.nb_num == 0 :\\n self.standalone_starlet_num += 1 \\n\\n divide_factor = starlet.nb_num + 2 * (starlet.spec_num - starlet.shared_spec_num )/self.ave_star_size\\n divide_factor_sum += divide_factor\\n divide_factor_int = round(divide_factor)\\n self.starlet_divide_factor_dist[divide_factor_int] = self.starlet_divide_factor_dist.get(divide_factor_int,0) + 1\\n if starlet.spec_num < starlet.shared_spec_num:\\n print(\\\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\\\")\\n print(\\\"with star \\\" + starlet.id + \\\" \\\" + str(starlet.spec_num) + \\\"is less than\\\" + str(starlet.shared_spec_num))\\n if starlet.spec_num > starlet.shared_spec_num:\\n self.starlet_lost_spec_num += starlet.spec_num - starlet.shared_spec_num\\n self.ave_divide_factor_starlet = divide_factor_sum/self.starlets_length\",\n \"def Sidetrack2Path(tree, sidetracks, s, t):\\n\\tvisited = set()\\t\\t# visited nodes\\n\\tpath = []\\t\\t# set of edges\\n\\tsidenodes = set(links[e][0] for e in sidetracks)\\t# nodes that needs to be sidetracked\\n\\tcurrent = s\\n\\twhile current != t:\\n\\t\\t# Loop detection\\n\\t\\tif current in visited:\\n\\t\\t\\treturn []\\n\\t\\telse:\\n\\t\\t\\tvisited.add(current)\\n\\t\\t# No loop is found yet, proceed one hop\\n\\t\\tif current in sidenodes:\\n\\t\\t\\tedge = [e for e in sidetracks if links[e][0] == current]\\n\\t\\t\\tcurrent = links[edge[0]][1]\\n\\t\\t\\tpath.append(edge[0])\\n\\t\\telse:\\n\\t\\t\\tedge = [i for i,e in enumerate(links) if e == (current,tree[current])]\\n\\t\\t\\tcurrent = links[edge[0]][1]\\n\\t\\t\\tpath.append(edge[0])\\n\\t# Destination reached. Return the path\\n\\treturn path\",\n \"def test_tree_splay() -> None:\\n t = generate_graph_resources(5)\\n field(t, (\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\")).references.append(\\n (FieldAddress(\\\"dr_2\\\", \\\"ds_2\\\", \\\"f1\\\"), \\\"to\\\")\\n )\\n field(t, (\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\")).references.append(\\n (FieldAddress(\\\"dr_3\\\", \\\"ds_3\\\", \\\"f1\\\"), \\\"to\\\")\\n )\\n field(t, (\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\")).references.append(\\n (FieldAddress(\\\"dr_4\\\", \\\"ds_4\\\", \\\"f1\\\"), \\\"to\\\")\\n )\\n field(t, (\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\")).references.append(\\n (FieldAddress(\\\"dr_5\\\", \\\"ds_5\\\", \\\"f1\\\"), \\\"to\\\")\\n )\\n field(t, (\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\")).identity = \\\"email\\\"\\n traversal = Traversal(DatasetGraph(*t), {\\\"email\\\": \\\"X\\\"})\\n\\n assert incoming_edges(traversal, CollectionAddress(\\\"dr_1\\\", \\\"ds_1\\\")) == {\\n Edge(\\n FieldAddress(\\\"__ROOT__\\\", \\\"__ROOT__\\\", \\\"email\\\"),\\n FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\"),\\n )\\n }\\n assert outgoing_edges(traversal, CollectionAddress(\\\"dr_1\\\", \\\"ds_1\\\")) == {\\n Edge(FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\"), FieldAddress(\\\"dr_3\\\", \\\"ds_3\\\", \\\"f1\\\")),\\n Edge(FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\"), FieldAddress(\\\"dr_4\\\", \\\"ds_4\\\", \\\"f1\\\")),\\n Edge(FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\"), FieldAddress(\\\"dr_5\\\", \\\"ds_5\\\", \\\"f1\\\")),\\n Edge(FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\"), FieldAddress(\\\"dr_2\\\", \\\"ds_2\\\", \\\"f1\\\")),\\n }\\n\\n assert outgoing_edges(traversal, CollectionAddress(\\\"dr_5\\\", \\\"ds_5\\\")) == set()\\n assert incoming_edges(traversal, CollectionAddress(\\\"dr_2\\\", \\\"ds_2\\\")) == {\\n Edge(FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\"), FieldAddress(\\\"dr_2\\\", \\\"ds_2\\\", \\\"f1\\\"))\\n }\\n assert incoming_edges(traversal, CollectionAddress(\\\"dr_3\\\", \\\"ds_3\\\")) == {\\n Edge(FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\"), FieldAddress(\\\"dr_3\\\", \\\"ds_3\\\", \\\"f1\\\"))\\n }\\n assert incoming_edges(traversal, CollectionAddress(\\\"dr_4\\\", \\\"ds_4\\\")) == {\\n Edge(FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\"), FieldAddress(\\\"dr_4\\\", \\\"ds_4\\\", \\\"f1\\\"))\\n }\\n assert incoming_edges(traversal, CollectionAddress(\\\"dr_5\\\", \\\"ds_5\\\")) == {\\n Edge(FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\"), FieldAddress(\\\"dr_5\\\", \\\"ds_5\\\", \\\"f1\\\"))\\n }\\n traversal_map, terminators = traversal.traversal_map()\\n assert traversal_map == {\\n \\\"__ROOT__:__ROOT__\\\": {\\\"from\\\": {}, \\\"to\\\": {\\\"dr_1:ds_1\\\": {\\\"email -> f1\\\"}}},\\n \\\"dr_1:ds_1\\\": {\\n \\\"from\\\": {\\\"__ROOT__:__ROOT__\\\": {\\\"email -> f1\\\"}},\\n \\\"to\\\": {\\n \\\"dr_2:ds_2\\\": {\\\"f1 -> f1\\\"},\\n \\\"dr_3:ds_3\\\": {\\\"f1 -> f1\\\"},\\n \\\"dr_4:ds_4\\\": {\\\"f1 -> f1\\\"},\\n \\\"dr_5:ds_5\\\": {\\\"f1 -> f1\\\"},\\n },\\n },\\n \\\"dr_2:ds_2\\\": {\\\"from\\\": {\\\"dr_1:ds_1\\\": {\\\"f1 -> f1\\\"}}, \\\"to\\\": {}},\\n \\\"dr_3:ds_3\\\": {\\\"from\\\": {\\\"dr_1:ds_1\\\": {\\\"f1 -> f1\\\"}}, \\\"to\\\": {}},\\n \\\"dr_4:ds_4\\\": {\\\"from\\\": {\\\"dr_1:ds_1\\\": {\\\"f1 -> f1\\\"}}, \\\"to\\\": {}},\\n \\\"dr_5:ds_5\\\": {\\\"from\\\": {\\\"dr_1:ds_1\\\": {\\\"f1 -> f1\\\"}}, \\\"to\\\": {}},\\n }\\n\\n assert set(terminators) == {\\n CollectionAddress(\\\"dr_2\\\", \\\"ds_2\\\"),\\n CollectionAddress(\\\"dr_3\\\", \\\"ds_3\\\"),\\n CollectionAddress(\\\"dr_4\\\", \\\"ds_4\\\"),\\n CollectionAddress(\\\"dr_5\\\", \\\"ds_5\\\"),\\n }\",\n \"def get_weight_from_minflow(self):\\n start_nodes = []\\n end_nodes = []\\n capacities = []\\n unit_costs = []\\n A = 0\\n s_prime = self.sink() + 1\\n t_prime = self.sink() + 2\\n x = self.sink() + 3\\n # for every edge in the graph, add edge to mincost flow instance with\\n # infinite capacity and cost 1\\n # also add backwards edge\\n for arc in self.arc_info.keys():\\n # forward edge\\n start_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"start\\\"],\\n self.arc_info[arc][\\\"destin\\\"]))\\n # backward edge\\n start_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n capacities.append(int(self.arc_info[arc][\\\"weight\\\"])) # no negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"destin\\\"],\\n self.arc_info[arc][\\\"start\\\"]))\\n # add (x,s) and (t,x) edges with same cap, cost as above\\n in_weight_x = 0\\n for in_arc in self.in_arcs_lists[self.sink()]:\\n in_weight_x += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight_x = 0\\n for out_arc in self.out_arcs_lists[self.source()]:\\n out_weight_x += self.arc_info[out_arc][\\\"weight\\\"]\\n # (x,s)\\n start_nodes.append(x)\\n end_nodes.append(self.source())\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.source()))\\n # backward\\n start_nodes.append(self.source())\\n end_nodes.append(x)\\n capacities.append(int(out_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.source(),\\n x))\\n # (t,x)\\n start_nodes.append(self.sink())\\n end_nodes.append(x)\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.sink(),\\n x))\\n # backward\\n start_nodes.append(x)\\n end_nodes.append(self.sink())\\n capacities.append(int(in_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.sink()))\\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\\n # and cost 0.\\n for v in self:\\n # process internal verts only, since we assume source and sink have\\n # no in and out edges respectively\\n if v != self.source() and v != self.sink():\\n # compute a-exc(v)\\n in_weight = 0\\n for in_arc in self.in_arcs_lists[v]:\\n in_weight += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight = 0\\n for out_arc in self.out_arcs_lists[v]:\\n out_weight += self.arc_info[out_arc][\\\"weight\\\"]\\n a_exc = out_weight - in_weight\\n if a_exc < 0:\\n # add edge (s', v)\\n start_nodes.append(s_prime)\\n end_nodes.append(v)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n v,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (v, t')\\n start_nodes.append(v)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n v,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # process x node\\n a_exc = out_weight_x - in_weight_x\\n if a_exc < 0:\\n # add edge (s', x)\\n start_nodes.append(s_prime)\\n end_nodes.append(x)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n x,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (x, t')\\n start_nodes.append(x)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n x,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # we must send flow of A from s_prime to t_prime\\n supplies = [0]*(len(self) + 3)\\n supplies[s_prime] = int(A)\\n supplies[t_prime] = int(-A)\\n # Instantiate a SimpleMinCostFlow solver.\\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\\n # Add each arc.\\n for i in range(len(start_nodes)):\\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\\n end_nodes[i], capacities[i], unit_costs[i])\\n # Add node supplies\\n for i in range(0, len(supplies)):\\n min_cost_flow.SetNodeSupply(i, supplies[i])\\n # Find the minimum cost flow between node s' and t'.\\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\\n print('Minimum cost:', min_cost_flow.OptimalCost())\\n print('')\\n print(' Arc Flow / Capacity Cost')\\n for i in range(min_cost_flow.NumArcs()):\\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\\n print('%1s -> %1s %3s / %3s %3s' % (\\n min_cost_flow.Tail(i),\\n min_cost_flow.Head(i),\\n min_cost_flow.Flow(i),\\n min_cost_flow.Capacity(i),\\n cost))\\n # update arcs\\n start = min_cost_flow.Tail(i)\\n destin = min_cost_flow.Head(i)\\n if start != s_prime and \\\\\\n start != t_prime and \\\\\\n start != x and \\\\\\n destin != s_prime and \\\\\\n destin != t_prime and \\\\\\n destin != x:\\n # if forward, increase flow. otherwise decrease.\\n print(\\\"Processing edge ({}, {})\\\".format(start, destin))\\n if start < destin:\\n sup_flow = min_cost_flow.Flow(i)\\n else:\\n sup_flow = -min_cost_flow.Flow(i)\\n temp_start = start\\n start = destin\\n destin = temp_start\\n print(\\\"Has become ({}, {}) with sup {}\\\".format(start,\\n destin,\\n sup_flow))\\n arc = self.get_arc(start, destin)\\n if (sup_flow != 0) or (\\\"lower_bound\\\" not in \\\\\\n self.arc_info[arc].keys()):\\n print(\\\"We should add this\\\")\\n old_flow = self.arc_info[arc][\\\"weight\\\"]\\n new_flow = old_flow + sup_flow\\n self.arc_info[arc][\\\"weight\\\"] = int(new_flow)\\n print(\\\"Edge ({},{}) weight is changed from {} to {}\\\".format(\\n start,\\n destin,\\n old_flow,\\n new_flow))\\n else:\\n print('There was an issue with the min cost flow input.')\\n #self.check_conservation_of_flow() # check that solution is valid\",\n \"def find_ports(self, lines):\\n ports = []\\n left = None\\n self.dists = []\\n for line in lines:\\n if left is None:\\n if self.is_left(line):\\n left = self.mid(line)\\n else:\\n if not self.is_left(line):\\n ports.append(int(left[0] + self.mid(line)[0]) // 2)\\n self.dists.append(left[0] - self.mid(line)[0])\\n left = None\\n # print(ports)\\n return ports\",\n \"def bfs_nodes_generator(graph, source, reverse=...):\\n ...\",\n \"def nodes_ratio(data: Data, position_against_soma=None, node_types=None, filter_layers=None):\\n soma = data.morphology.get_soma()\\n if position_against_soma=='above':\\n criterion=lambda nod:((nod['type'] in node_types) if node_types is not None else True) and nod['y']<soma['y']\\n elif position_against_soma=='below':\\n criterion=lambda nod:((nod['type'] in node_types) if node_types is not None else True) and nod['y']>soma['y']\\n else:\\n criterion=lambda nod:nod['type'] in node_types if node_types is not None else True\\n num_type_nodes = data.morphology.get_node_by_types(node_types)\\n if filter_layers and isinstance(filter_layers, list):\\n result = {}\\n for layer in filter_layers:\\n filter_layer_depth = data.reference_layer_depths.get(layer)\\n y_min, y_max, is_scale = filter_layer_depth.pia_side, filter_layer_depth.wm_side, filter_layer_depth.scale\\n if is_scale:\\n selected_nodes = data.morphology.filter_nodes(lambda nod: criterion(nod) and y_min<nod['y']<y_max)\\n else:\\n selected_nodes = data.morphology.filter_nodes(lambda nod: criterion(nod) and nod['y']>y_min)\\n result[layer]=len(selected_nodes)/len(num_type_nodes)\\n return result\\n else:\\n selected_nodes = data.morphology.filter_nodes(criterion)\\n return len(selected_nodes)/len(num_type_nodes)\",\n \"def max_flow(self, source, sink):\\n\\n path = self.valid_path(source, sink, [])\\n\\n while path:\\n # get the maximum possible flow that can be taken from this path:\\n max_flow = min([edge.capacity for edge in path])\\n for edge in path:\\n self.edges[edge] += max_flow\\n path = self.valid_path(source, sink, [])\\n\\n # Compute all the flows from the neighbors of source:\\n return sum([self.edges[edge] for edge in self.adjacents[source]])\",\n \"def get_fraction_links_active(self):\\n active_links = 0\\n for (a,b) in self.model.model.edges_iter():\\n (a_id, a_traits) = self.model.get_agent_by_id(a)\\n (b_id, b_traits) = self.model.get_agent_by_id(b)\\n prob = analysis.calc_probability_interaction_axelrod(a_traits, b_traits)\\n if prob > 0.0 and prob < 1.0:\\n #log.debug(\\\"active link (%s %s) prob: %s a_trait: %s b_trait: %s\\\", a_id, b_id, prob, a_traits, b_traits)\\n active_links += 1\\n num_links_total = self.model.model.number_of_edges()\\n #log.debug(\\\"active links: %s total links: %s\\\", active_links, num_links_total)\\n fraction_active = float(active_links) / num_links_total\\n return fraction_active\",\n \"def find_sharpest_fork(nodes):\\n pair_list = []\\n Dis = np.array([])\\n for n in nodes:\\n if n.parent is not None:\\n if n.parent.parent is not None:\\n a = n.parent.children\\n if(isinstance(a, list)):\\n if(len(a)==2):\\n n1 = a[0]\\n n2 = a[1]\\n if(len(n1.children) == 0 and len(n2.children) == 0):\\n pair_list.append([n1 , n2])\\n dis = LA.norm(a[0].xyz - a[1].xyz,2)\\n Dis = np.append(Dis,dis)\\n if(len(Dis)!= 0):\\n (b,) = np.where(Dis == Dis.min())\\n sharpest_pair = pair_list[b[0]]\\n distance = Dis.min()\\n else:\\n sharpest_pair = [0,0]\\n distance = 0.\\n return sharpest_pair, distance\",\n \"def bfs_paths(self, start: str, goal: str) -> List[Path]:\\n queue = [(start, [start])]\\n while queue:\\n (node, path) = queue.pop(0)\\n if node not in self.graph:\\n yield []\\n for _next in set(self.graph[node]) - set(path):\\n if _next == goal:\\n yield path + [_next]\\n elif _next in self.graph:\\n queue.append((_next, path + [_next]))\",\n \"def get_all_social_paths(self, user_id): #each user v v each path V V\\n # output example- {1: [1], 8: [1, 8], 10: [1, 10], 5: [1, 5], 2: [1, 10, 2], 6: [1, 10, 6], 7: [1, 10, 2, 7]}\\n visited = {} # Note that this is a dictionary, not a set\\n # Need to do a bfs using the user id\\n # first step is to traverse the graph and record all the vertices as keys in visited using bft\\n # then take those keys and use bfs on each, using user_id as the starting node and and the key as\\n # the destination node\\n\\n # Modification of BFT\\n # create an empty dict\\n # q = Queue()\\n q = []\\n\\n # init enqueue the starting node\\n q.append(user_id)\\n\\n while len(q) > 0:\\n # Dequeue the first item\\n v = q.pop(0)\\n # If it's not been visited:\\n if v not in visited:\\n # Mark as visited (i.e. add to the visited set)\\n visited[v] = []\\n\\n # Do something with the node\\n print(f\\\"Visited {v}\\\")\\n\\n # Add all neighbors to the queue\\n for next_vert in self.friendships[v]:\\n q.append(next_vert)\\n\\n # once visited is filled, then we start the bfs\\n #print('vv',visited)\\n possible_paths = {}\\n #run a bfs for each key in visited\\n for v in visited:\\n possible_paths[v] = []\\n \\n if v == user_id:\\n visited[v] = [user_id]\\n\\n path = []\\n while len(path) < len(visited):\\n\\n # Add all neighbors to the queue\\n for next_vert in self.friendships[v]:\\n print(possible_paths[v])\\n # copy the path\\n # temp_path = list(path)\\n # temp_path.append(next_vert)\\n # add path to possible_paths\\n path.append(next_vert)\\n\\n possible_paths[v].append(path) # HAVE TO USE QUEUE OR STACK, THEY ENSURE THE NEIGHBORS\\n # FOLLOW THE CORRECT ORDER WHEN LOOPING \\n\\n if v == path[-1]:\\n \\n # IF SO, RETURN PATH\\n visited[v] = path\\n break\\n\\n # for x in visited:\\n # bfs(user_id, x)\\n # visited[x].add(path)\\n \\n print('pct of total users in network', len(visited[1])/len(visited))\\n print('degrees of separation', len(visited[1]) - 1)\\n return visited\",\n \"def findrelations(planet, comingFrom, relations, borders):\\n transfers = []\\n transfersPath = 0\\n \\n relations = []\\n for i in relations:\\n if planet in i:\\n # both orbits and centers can be saved except itself and the one coming from\\n for j in i: \\n if j not in (planet, comingFrom):\\n relations.append(j)\\n \\n for rel in relations:\\n if rel == \\\"SAN\\\":\\n return transfers\\n elif rel not in borders:\\n transfers +=1\\n transfers += findrelations(rel, comingFrom, relations, borders)\\n \\n transfers.append(transfersPath-1)\\n return transfers\",\n \"def _get_full_graph(self):\",\n \"def get_fraction_links_active(self):\\n active_links = 0\\n for (a,b) in self.model.model.edges_iter():\\n (a_id, a_traits) = self.model.get_agent_by_id(a)\\n (b_id, b_traits) = self.model.get_agent_by_id(b)\\n prob = analysis.calc_probability_interaction_extensible(a_traits, b_traits)\\n if prob > 0.0 and prob < 1.0:\\n #log.debug(\\\"active link (%s %s) prob: %s a_trait: %s b_trait: %s\\\", a_id, b_id, prob, a_traits, b_traits)\\n active_links += 1\\n num_links_total = self.model.model.number_of_edges()\\n #log.debug(\\\"active links: %s total links: %s\\\", active_links, num_links_total)\\n fraction_active = float(active_links) / num_links_total\\n return fraction_active\",\n \"def path_to_actor(self, source, target):\\r\\n #shortest path\\r\\n path = nx.shortest_path(self.graph, source, target)\\r\\n #shortest path length....\\r\\n len_path = nx.shortest_path_length(self.graph, source, target)\\r\\n return path, len_path/2\",\n \"def createBridgeSets(blocksize,operating,MPSS):\\n sets = tuple()\\n xul = blocksize[0]-operating\\n xdl = operating\\n yul = int(blocksize[0]/2+operating)\\n ydl = int(blocksize[0]/2-operating)\\n xts = xul\\n xbs = xdl\\n for i in range(MPSS):\\n sets+=(tuple(product(numpy.arange(xdl,xul,1),numpy.arange(ydl,yul,1))),)\\n xdl+=operating\\n xul-=operating\\n ydl-=operating\\n yul+=operating\\n return sets,sets[::-1]\",\n \"def detect_splits(self):\\n logg.info(' abstracted graph will have {} nodes'.format(self.n_splits+1))\\n indices_all = np.arange(self.X.shape[0], dtype=int)\\n segs = [indices_all]\\n if False: # this is safe, but not compatible with on-the-fly computation\\n tips_all = np.array(np.unravel_index(np.argmax(self.Dchosen), self.Dchosen.shape))\\n else:\\n if self.iroot is not None:\\n tip_0 = np.argmax(self.Dchosen[self.iroot])\\n else:\\n tip_0 = np.argmax(self.Dchosen[0]) # just a random index, here fixed to \\\"0\\\"\\n tips_all = np.array([tip_0, np.argmax(self.Dchosen[tip_0])])\\n # we keep a list of the tips of each segment\\n segs_tips = [tips_all]\\n if self.clusters_precomputed_names:\\n self.segs_names_original = [', '.join(self.clusters_precomputed_names)]\\n segs_undecided = [True]\\n segs_adjacency = [[]]\\n segs_distances = np.zeros((1, 1))\\n segs_adjacency_nodes = [{}]\\n # logg.info(' do not consider groups with less than {} points for splitting'\\n # .format(self.min_group_size))\\n for ibranch in range(self.n_splits):\\n if self.clusters == 'unconstrained_segments':\\n iseg, new_tips = self.select_segment(segs, segs_tips, segs_undecided)\\n if iseg == -1:\\n logg.info('... partitioning converged')\\n break\\n logg.info('... branching {}:'.format(ibranch + 1),\\n 'split group', iseg)\\n segs_distances = self.do_split(segs, segs_tips,\\n segs_undecided,\\n segs_adjacency,\\n segs_distances,\\n iseg, new_tips)\\n else:\\n logg.msg(' split', ibranch + 1, v=4)\\n stop, segs_distances = self.do_split_constrained(segs, segs_tips,\\n segs_adjacency,\\n segs_adjacency_nodes,\\n segs_distances)\\n if stop: break\\n\\n # segments\\n self.segs = segs\\n self.segs_tips = segs_tips\\n self.segs_sizes = []\\n for iseg, seg in enumerate(self.segs): self.segs_sizes.append(len(seg))\\n\\n # the full, unscaled adjacency matrix\\n self.segs_adjacency_full_attachedness = 1/segs_distances\\n # if self.attachedness_measure == 'connectedness':\\n # norm = np.sqrt(np.multiply.outer(self.segs_sizes, self.segs_sizes))\\n # self.segs_adjacency_full_attachedness /= norm\\n self.segs_adjacency_full_confidence, self.segs_adjacency_tree_confidence \\\\\\n = self.compute_adjacency_confidence(\\n self.segs_adjacency_full_attachedness,\\n segs_adjacency,\\n self.tree_based_confidence)\\n np.fill_diagonal(self.segs_adjacency_full_attachedness, 0)\",\n \"def get_GNS_cut(self):\\n # we build the optimization around the casted digraph instead of multidigraph\\n # for simplicity\\n G = self.base_digraph\\n s_1 = self.sources[0]\\n s_2 = self.sources[1]\\n t_1 = self.destinations[0]\\n t_2 = self.destinations[1]\\n edges = G.edges()\\n nodes = G.nodes()\\n\\n try:\\n\\n # Great an gurobi instance of the optimization model\\n m = Model(\\\"GNS\\\")\\n m.setParam('OutputFlag', False)\\n\\n x_v = {}\\n # vertex variables for s_1, t_1 cut\\n for v in nodes:\\n x_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n x_e = {}\\n # edge variables for s_1, t_1 cut\\n for (u,v) in edges:\\n x_e[u,v] = m.addVar(vtype=GRB.BINARY)\\n\\n y_v = {}\\n # vertex variables for s_2, t_2 cut\\n for v in nodes:\\n y_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n y_e = {}\\n # edge variables for s_2, t_2 cut\\n for (u,v) in edges:\\n y_e[u,v] = m.addVar(vtype=GRB.BINARY)\\n\\n z_v = {}\\n # vertex variables for s_2, t_1 cut\\n for v in nodes:\\n z_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n z_e = {}\\n # edge variables for s_2, t_1 cut\\n for (u,v) in edges:\\n z_e[u,v] = m.addVar(vtype=GRB.BINARY)\\n\\n e = {}\\n # GNS indicator variable\\n for (u,v) in edges:\\n e[u,v] = m.addVar(vtype=GRB.BINARY, obj=G[u][v]['capacity'])\\n\\n # Done with decision variable creation\\n # update model\\n m.update()\\n\\n # Constraints\\n # 1. Constraints for s_1 - t_1 cut\\n for (u,v) in edges:\\n if (u,v) == (s_1, t_1):\\n m.addConstr(x_e[u,v] >= 1)\\n elif u == s_1:\\n m.addConstr(x_v[v] + x_e[u,v] >= 1)\\n elif v == t_1:\\n m.addConstr(-x_v[u] + x_e[u,v] >= 0)\\n else:\\n m.addConstr(x_v[v] - x_v[u] + x_e[u,v] >= 0)\\n\\n # 2. Constraints for s_2 - t_2 cut\\n for (u,v) in edges:\\n if (u,v) == (s_2, t_2):\\n m.addConstr(y_e[u,v] >= 1)\\n elif u == s_2:\\n m.addConstr(y_v[v] + y_e[u,v] >= 1)\\n elif v == t_2:\\n m.addConstr(-y_v[u] + y_e[u,v] >= 0)\\n else:\\n m.addConstr(y_v[v] - y_v[u] + y_e[u,v] >= 0)\\n\\n # 3. Constraints for s_2 - t_1 cut\\n for (u,v) in edges:\\n if (u,v) == (s_2, t_1):\\n m.addConstr(z_e[u,v] >= 1)\\n elif u == s_2:\\n m.addConstr(z_v[v] + z_e[u,v] >= 1)\\n elif v == t_1:\\n m.addConstr(-z_v[u] + z_e[u,v] >= 0)\\n else:\\n m.addConstr(z_v[v] - z_v[u] + z_e[u,v] >= 0)\\n\\n # 4. Constraints for e[u,v] >= max(x_e[u,v], y_e[u,v], z_e[u,v])\\n for (u,v) in edges:\\n m.addConstr(e[u,v] >= x_e[u,v])\\n m.addConstr(e[u,v] >= y_e[u,v])\\n m.addConstr(e[u,v] >= z_e[u,v])\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n print \\\"Min GNS cut value = \\\" + str(m.objVal)\\n print \\\"GNS cut edges:\\\"\\n\\n for u,v in edges:\\n if e[u,v].x != 0:\\n print (u,v)\\n print \\\"s1-t1 cut edges in GNS:\\\"\\n for u,v in edges:\\n if x_e[u,v].x != 0:\\n print (u,v)\\n\\n print \\\"s2-t2 cut edges in GNS:\\\"\\n for u,v in edges:\\n if y_e[u,v].x != 0:\\n print (u,v)\\n\\n print \\\"s2-t1 cut edges in GNS:\\\"\\n for u,v in edges:\\n if z_e[u,v].x != 0:\\n print (u,v)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong\\\"\\n\\n except GurobiError:\\n print ('Error report from Gurobi')\",\n \"def transmission (graph, r=.5, m=.5):\\n\\n routes = r*nx.adjacency_matrix(graph)\\n medicn = m*sp.eye(nx.number_of_nodes(graph))\\n\\n return routes + medicn\",\n \"def get_path(self, sim, app_name, message, topology_src, alloc_DES, alloc_module, traffic, from_des):\\n node_src = topology_src\\n DES_dst = alloc_module[app_name][message.dst]\\n\\n # print (\\\"GET PATH\\\")\\n # print (\\\"\\\\tNode _ src (id_topology): %i\\\" % node_src)\\n # print (\\\"\\\\tRequest service: %s \\\" % message.dst)\\n # print (\\\"\\\\tProcess serving that service: %s \\\" % DES_dst)\\n\\n bestPath = []\\n bestDES = []\\n min_path_size = float('inf')\\n myDigraph = graph2digraph(sim.topology.G)\\n\\n for des in DES_dst: ## In this case, there are only one deployment\\n dst_node = alloc_DES[des]\\n print (\\\"\\\\t Looking the path to id_node: %i\\\" % dst_node)\\n\\n path = list(nx.shortest_path(myDigraph, source=node_src, target=dst_node, weight='BW'))\\n actual_path_size = nx.shortest_path_length(myDigraph, source=node_src, target=dst_node, weight='BW')\\n\\n # Calculo do fluxo maximo no grafo desde 1 ate 6\\n # flow_value, flow_dict = list(nx.maximum_flow(myDigraph, _s=0, _t=6, capacity=\\\"BW\\\"))\\n # print(\\\"MAXFLOW VALUE: \\\", flow_value)\\n # print(\\\"MAXFLOW DICT: \\\", flow_dict)\\n\\n print (\\\"\\\\t\\\\t candidate to best path: \\\" + str(path) + \\\" Size = \\\" + str(actual_path_size))\\n\\n if actual_path_size < min_path_size:\\n min_path_size = actual_path_size\\n minPath = path\\n bestDES = des\\n\\n bestPath = [minPath]\\n bestDES = [des]\\n print (\\\"best path is: \\\", bestPath, \\\" with weigth \\\", min_path_size)\\n print \\\"---------------------------------------------------------\\\"\\n return bestPath, bestDES\",\n \"def greedy(self):\\n # for each node, find the incoming link with the highest score.\\n max_scores = {}\\n max_sources = {}\\n for source, target in self.iteredges():\\n score = self.get_score(source, target)\\n max_score = max_scores.get(target)\\n if max_score is None or score > max_score:\\n max_scores[target] = score\\n max_sources[target] = source\\n # then build a graph out of just these links.\\n succs = dict((n, []) for n in self)\\n for target, source in max_sources.items():\\n succs[source].append(target)\\n return Digraph(succs, self.get_score, self.get_label)\",\n \"def internal_link_density(self, node_list):\\n N = len(node_list)\\n n_links = self.number_internal_links(node_list)\\n if self.directed:\\n return float(n_links) / (N * (N - 1))\\n else:\\n return 2 * float(n_links) / (N * (N - 1))\",\n \"def __edgeRouter(self):\\r\\n def getEndpoint(nodeTuple, pointList, direction, isReversedEdge):\\r\\n \\\"\\\"\\\" Gets the nearest arrow endpoint. Handles edge reversal \\\"\\\"\\\"\\r\\n if((direction == 'start' and not isReversedEdge)\\r\\n or (direction == 'end' and isReversedEdge)): \\r\\n endNode = nodeTuple[0]\\r\\n if(isReversedEdge):\\r\\n ix = -2\\r\\n iy = -1\\r\\n else:\\r\\n ix = 0\\r\\n iy = 1\\r\\n else: \\r\\n endNode = nodeTuple[1]\\r\\n if(isReversedEdge):\\r\\n ix = 0\\r\\n iy = 1\\r\\n else:\\r\\n ix = -2 \\r\\n iy = -1 \\r\\n \\r\\n # Is it connected to a named port!?!\\r\\n if(endNode.isConnectedByNamedPort(edgeObject)):\\r\\n handler = endNode.getConnectedByNamedPortHandler(nodeTuple[2]) \\r\\n return dc.coords(handler)[:2]\\r\\n \\r\\n # Not a named port...\\r\\n return list(endNode.getClosestConnector2Point( endNode, pointList[ix], \\r\\n pointList[iy])) \\r\\n \\r\\n \\r\\n \\r\\n #todo: improve method for spline arrows + add comments + optimize?\\r\\n print '----------------Dummy Edge Routing-----------------'\\r\\n for dummyEdge in NodeWrapper.ID2LayerEdgeDict.keys():\\r\\n \\r\\n dummyList = NodeWrapper.ID2LayerEdgeDict[dummyEdge]\\r\\n dummyNode = dummyList[0]\\r\\n dummyChild = dummyNode.children.keys()[0]\\r\\n linkFlagList = dummyNode.children[dummyChild]\\r\\n \\r\\n # Real nodes at start/end of the edge\\r\\n edgeSourceNode = dummyNode.parents.keys()[0]\\r\\n edgeSourceNode = edgeSourceNode.getASGNode().graphObject_\\r\\n dummyNode = dummyList[-1]\\r\\n edgeTargetNode = dummyNode.children.keys()[0]\\r\\n #print 'Dummy edge number', dummyEdge,\\r\\n #print dummyList[0].parents.keys()[0].getName(), edgeTargetNode.getName()\\r\\n edgeTargetNode = edgeTargetNode.getASGNode().graphObject_\\r\\n nodeTuple = [edgeSourceNode, edgeTargetNode, None]\\r\\n \\r\\n # Some edges are internally reversed to break cycles, when drawing\\r\\n # this must be taken into account\\r\\n isReversedEdge = False\\r\\n edgesToRoute = []\\r\\n for linkNode, isReversed in linkFlagList:\\r\\n edgesToRoute.append(linkNode)\\r\\n if(isReversed):\\r\\n isReversedEdge = True\\r\\n \\r\\n # Get all the points the edge must pass through (sorted by layer order)\\r\\n dummyList.sort(lambda a, b: cmp(a.getLayer(), b.getLayer()))\\r\\n if(isReversedEdge):\\r\\n dummyList.reverse()\\r\\n sortedDummyRouteList = []\\r\\n for node in dummyList:\\r\\n sortedDummyRouteList += node.getEdgePosition()\\r\\n \\r\\n # Set the coordinates of the edge directly \\r\\n # This is complicated by the fact that AToM3 treats edges as two\\r\\n # segments that join poorly (for spline arrows)\\r\\n for edgeObject in edgesToRoute: \\r\\n dc = edgeObject.graphObject_.dc\\r\\n linkObj = edgeObject.graphObject_ \\r\\n tag = linkObj.tag\\r\\n \\r\\n if(isReversedEdge):\\r\\n inPoint = dc.coords( tag + \\\"2ndSeg0\\\" )[:2]\\r\\n outPoint = dc.coords( tag + \\\"1stSeg0\\\" )[:2]\\r\\n else:\\r\\n inPoint = dc.coords( tag + \\\"1stSeg0\\\" )[:2]\\r\\n outPoint = dc.coords( tag + \\\"2ndSeg0\\\" )[:2]\\r\\n \\r\\n #print 'Dummy route', sortedDummyRouteList\\r\\n numPoints = len(sortedDummyRouteList) / 2\\r\\n # Add 2 extra control points for odd case (to make splines nice)\\r\\n if(numPoints % 2 == 1):\\r\\n if(numPoints == 1):\\r\\n center = sortedDummyRouteList\\r\\n else:\\r\\n start = sortedDummyRouteList[:numPoints - 1]\\r\\n end = sortedDummyRouteList[numPoints + 1:]\\r\\n center = sortedDummyRouteList[numPoints - 1:numPoints + 1]\\r\\n \\r\\n if(not isReversedEdge):\\r\\n newMid1 = [center[0], center[1] - 20]\\r\\n newMid2 = [center[0], center[1] + 20]\\r\\n else:\\r\\n newMid2 = [center[0], center[1] - 20]\\r\\n newMid1 = [center[0], center[1] + 20]\\r\\n \\r\\n \\r\\n if(numPoints == 1):\\r\\n sortedDummyRouteList = newMid1 + center + newMid2 \\r\\n else:\\r\\n sortedDummyRouteList = start + newMid1 + center + newMid2 + end\\r\\n centerIndex = numPoints - 1 + 2\\r\\n \\r\\n # Add 1 extra control point for even case (to make splines nice)\\r\\n else:\\r\\n start = sortedDummyRouteList[:numPoints]\\r\\n end = sortedDummyRouteList[numPoints:]\\r\\n center = [start[-2] + (end[0] - start[-2]) / 2, \\r\\n start[-1] + (end[1] - start[-1]) / 2]\\r\\n sortedDummyRouteList = start + center + end \\r\\n centerIndex = numPoints\\r\\n \\r\\n # Now I know where the center is... so lets move the center object\\r\\n # Is the edge object a hyperlink?\\r\\n if(len(edgeObject.in_connections_ + edgeObject.out_connections_) > 2):\\r\\n fromObjs = []\\r\\n for semObj in edgeObject.in_connections_:\\r\\n fromObjs.append(semObj.graphObject_)\\r\\n toObjs = []\\r\\n for semObj in edgeObject.out_connections_:\\r\\n toObjs.append(semObj.graphObject_)\\r\\n optimizerHyperLink(dc, linkObj, fromObjs, toObjs, 0, 0, 0, center )\\r\\n continue\\r\\n \\r\\n else:\\r\\n linkObj.moveTo(* center)\\r\\n \\r\\n # Go through the 2 segments in the link\\r\\n nodeTuple[2] = edgeObject\\r\\n for connTuple in linkObj.connections:\\r\\n itemHandler = connTuple[0]\\r\\n direction = connTuple[1]\\r\\n \\r\\n if( direction ): \\r\\n inPoint = getEndpoint(nodeTuple, sortedDummyRouteList,\\r\\n 'start', isReversedEdge)\\r\\n\\r\\n segCoords = inPoint + sortedDummyRouteList[:centerIndex+2]\\r\\n else: \\r\\n outPoint = getEndpoint(nodeTuple, sortedDummyRouteList,\\r\\n 'end', isReversedEdge) \\r\\n segCoords = sortedDummyRouteList[centerIndex:] + outPoint\\r\\n segCoords = self.__reverseCoordList(segCoords)\\r\\n \\r\\n # Applies the changed coords to the canvas\\r\\n dc.coords( * [itemHandler] + segCoords ) \\r\\n \\r\\n # This may change the associated link drawings: \\r\\n # move them to the new point \\r\\n if( direction ):\\r\\n linkObj.updateDrawingsTo(inPoint[0], inPoint[1], itemHandler, \\r\\n segmentNumber=1)\\r\\n else:\\r\\n linkObj.updateDrawingsTo(outPoint[0], outPoint[1], itemHandler, \\r\\n segmentNumber=2)\",\n \"def _mout_edges(nodes):\\n n = nodes.shape[0]\\n edges = []\\n for i in range(0, n - 1):\\n for j in range(i, n):\\n if abs(nodes[i, 0] - nodes[j, 0]) > 1:\\n break\\n elif abs(nodes[i, 0] - nodes[j, 0]) == 1 and \\\\\\n abs(nodes[i, 1] - nodes[j, 1]) == 0:\\n edges.append([i, j])\\n elif abs(nodes[i, 1] - nodes[j, 1]) == 1:\\n edges.append([i, j])\\n return edges\",\n \"def naiveGlobalRouting(self):\\n for e_list in self.s2e.values():\\n for e in e_list:\\n slot_path = []\\n src_slot = self.v2s[e.src]\\n dst_slot = self.v2s[e.dst]\\n slot_path.append(src_slot)\\n\\n curr = src_slot\\n len_x = src_slot.getLenX()\\n len_y = src_slot.getLenY()\\n\\n # first go in X direction\\n x_diff = curr.getPositionX() - dst_slot.getPositionX()\\n if x_diff:\\n dir = 'LEFT' if x_diff > 0 else 'RIGHT'\\n for i in range(int(abs(x_diff/len_x))):\\n curr = self.slot_manager.createSlotForRouting(curr.getNeighborSlotName(dir))\\n slot_path.append(curr)\\n\\n y_diff = curr.getPositionY() - dst_slot.getPositionY()\\n if y_diff:\\n dir = 'DOWN' if y_diff > 0 else 'UP'\\n for i in range(int(abs(y_diff/len_y))):\\n curr = self.slot_manager.createSlotForRouting(curr.getNeighborSlotName(dir))\\n slot_path.append(curr)\\n \\n assert curr == dst_slot\\n \\n slot_path = slot_path[1:-1] # exclude the src and the dst\\n logging.info(f'{e.name}: {self.v2s[e.src].getName()} -> {self.v2s[e.dst].getName()} : ' + ' '.join(s.getName() for s in slot_path))\\n self.e_name2path[e.name] = slot_path\",\n \"def bandwidth_share(self, nodes_efficiency: Dict[str, float]) -> Dict[str, float]:\\n pass\",\n \"def run_dfs(self,s):\\n if self.verbose: print('entering run_dfs with s = ',s)\\n new_states = [self.succ(s,a) for a in self.actions(s)]\\n results = []\\n\\n for ns in new_states:\\n if self.verbose: print('considering new state = ',ns)\\n end = self.is_end(ns)\\n if end:\\n result = self.result(ns)\\n if result is not None:\\n results.append(result)\\n else:\\n results += self.run_dfs(ns)\\n return results\",\n \"def sage_graph(self):\\n self.fe.load_cache()\\n edges = []\\n is_bipartite = self.variant.is_bipartite()\\n for X in self.L:\\n for Y in self.L:\\n a = self.op_norm(X, Y)\\n if not self.K.is_zero(a):\\n for c in self.K.unit_group:\\n d = a - c\\n if X != Y or c < d or is_bipartite:\\n edges.append(((X, c, False), (Y, d, is_bipartite)))\\n if X == Y and not is_bipartite:\\n break\\n return sage.all.Graph(edges)\",\n \"def get_network_ratio(df, edges, initial_buffer=500):\\n\\n # intersection-based join\\n buff = edges.buffer(0.01) # to avoid floating point error\\n inp, res = buff.sindex.query_bulk(df.geometry, predicate=\\\"intersects\\\")\\n intersections = (\\n df.iloc[inp]\\n .reset_index(drop=True)\\n .intersection(buff.iloc[res].reset_index(drop=True))\\n )\\n mask = intersections.area > 0.0001\\n intersections = intersections[mask]\\n inp = inp[mask]\\n lengths = intersections.area\\n grouped = lengths.groupby(inp)\\n totals = grouped.sum()\\n ints_vect = []\\n for name, group in grouped:\\n ratios = group / totals.loc[name]\\n ints_vect.append({res[item[0]]: item[1] for item in ratios.iteritems()})\\n\\n edge_dicts = pd.Series(ints_vect, index=totals.index)\\n\\n # nearest neighbor join\\n nans = df.index.difference(edge_dicts.index)\\n buffered = df.iloc[nans].buffer(initial_buffer)\\n additional = []\\n for orig, geom in zip(df.iloc[nans].geometry, buffered.geometry):\\n query = edges.sindex.query(geom, predicate=\\\"intersects\\\")\\n b = initial_buffer\\n while query.size == 0:\\n query = edges.sindex.query(geom.buffer(b), predicate=\\\"intersects\\\")\\n b += initial_buffer\\n additional.append({edges.iloc[query].distance(orig).idxmin(): 1})\\n\\n additional = pd.Series(additional, index=nans)\\n ratios = pd.concat([edge_dicts, additional]).sort_index()\\n result = pd.DataFrame()\\n result[\\\"edgeID_keys\\\"] = ratios.apply(lambda d: list(d.keys()))\\n result[\\\"edgeID_values\\\"] = ratios.apply(lambda d: list(d.values()))\\n result.index = df.index\\n return result\",\n \"def construct_fast_graph_connection(coord_list, radie):\\n\\n connection_distance = []\\n connection = []\\n coord_list_tree = scipy.spatial.cKDTree(coord_list)\\n for j, data in enumerate(coord_list):\\n '''save nodes which are in range'''\\n connections_ckd = coord_list_tree.query_ball_point(data, radie)\\n for i in connections_ckd:\\n #only save upper half of the matrix\\n if i > j:\\n #save the connection\\n connection.append([j, i])\\n #save the relative distance of the nodes\\n connection_distance.append(np.hypot(coord_list[i,0]-data[0], coord_list[i,1]-data[1]))\\n\\n connection_distance = np.array(connection_distance)\\n connection = np.array(connection)\\n\\n\\n return connection, connection_distance\",\n \"def test_find_path_dfs():\\n g = Graph()\\n node_1 = Node({'A':['B','C']})\\n g.add(node_1)\\n node_2 = Node({'B':['C','D']})\\n g.add(node_2)\\n node_3 = Node({'C':['D']})\\n g.add(node_3)\\n node_4 = Node({'D':['C']})\\n g.add(node_4)\\n node_5 = Node({'E':['C']})\\n g.add(node_5)\\n\\n # zero path between node_1 and node_5\\n path_0 = g.find_path_dfs(node_1, node_5)\\n assert path_0 == None\\n\\n # only one path between node_5 and node_4\\n path_1 = g.find_path_dfs(node_5, node_4)\\n assert [ node.name for node in path_1 ] == [ node_5.name, node_3.name, node_4.name ]\\n\\n # three paths between node_1 and node_3, verify anyone of the three is returned\\n path_3 = g.find_path_dfs(node_1, node_3)\\n assert [ node.name for node in path_3 ] == [ node_1.name, node_2.name, node_3.name ] or \\\\\\n [ node.name for node in path_3 ] == [ node_1.name, node_2.name, node_4.name, node_3.name ] or \\\\\\n [ node.name for node in path_3 ] == [ node_1.name, node_3.name ]\",\n \"def trapezium_rule(f, m, x, a, b, n):\\n h = (b-a)/float(n)\\n s = 0.5*(f(m, x, a) + f(m, x, b))\\n for i in range(n):\\n s = s + f(m, x, a + i*h)\\n return h*s\",\n \"def compute_equal_flow_allocations(target_graph, K=3):\\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\\n flow_allocation_seed_number = 0xDEAD_BEEF\\n np.random.seed(flow_allocation_seed_number)\\n flows = []\\n for node in target_graph.nodes:\\n possible_destination_nodes = set(target_graph.nodes) - set([node])\\n [destination_node] = np.random.choice(list(possible_destination_nodes), 1, replace=False)\\n # shortest_paths = all_shortest_paths(target_graph, node, destination_node.item())\\n shortest_paths = sorted(nx.all_simple_paths(target_graph, node, destination_node.item(),\\n cutoff=3),\\n key=lambda p: len(p))\\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\\n the_flow = Flow( source_node = node\\n , destination_node = destination_node.item()\\n , flow_tx_rate = 10.0\\n , paths = k_shortest_paths\\n , splitting_ratio = [1/K]*K\\n )\\n flows.append(the_flow)\\n \\n return flow_allocation_seed_number, flows\",\n \"def get_urls(*params: str, num_of_links: int = 1) -> list:\\n urls = []\\n try:\\n for i in range(num_of_links):\\n url = \\\"https://finviz.com/screener.ashx?v=111\\\"\\n codes = ','.join(rts_codes[len(rts_codes)*(num_of_links - i - 1)//num_of_links:(len(rts_codes)*(num_of_links - i)//num_of_links)])\\n payload = {\\\"FT\\\": 2,\\\"f\\\": params,\\\"t\\\": codes}\\n req = requests.get(url, params=payload)\\n if len(req.url) > 2900:\\n urls = []\\n num_of_links += 1\\n urls = get_urls(*params, num_of_links=num_of_links)\\n else:\\n urls.append(req.url)\\n return (urls)\\n except Exception as e:\\n print (e)\\n return None\",\n \"def pair_frame(captured_file, frame_seq):\\n rid = 0\\n all_frame = {}\\n fs_relation = {} # frame_stream_relation, mapping from stream number to one or more rid\\n get_pairing = \\\"tshark -2 -r {} -R '' -Y 'frame.number > 0 && http.request' -T fields -e tcp.stream -e frame.number -e http.response_in\\\"\\n \\n # Run get_pairing command\\n pairs = run_command(get_pairing.format(captured_file), False)\\n\\n # Associate each request and response node with its frame number in a dict\\n for i in range(0, len(frame_seq)):\\n cur_node = frame_seq[i]\\n all_frame[cur_node.get_frame()] = cur_node\\n \\n all_stream = []\\n for p in pairs:\\n pl = p.decode('utf8').rstrip('\\\\n').split('\\\\t')\\n cur_sn = int(pl[0]) # current_stream_number\\n try:\\n fs_relation[cur_sn]\\n except KeyError:\\n fs_relation[cur_sn] = []\\n all_stream.append(cur_sn)\\n fs_relation[cur_sn].append(rid)\\n\\n req_fn = int(pl[1]) # request_frame\\n all_frame[req_fn].set_req()\\n all_frame[req_fn].set_rid(rid)\\n\\n try:\\n res_fn = int(pl[2]) # response_frame\\n all_frame[res_fn].set_res()\\n all_frame[res_fn].set_rid(rid)\\n except ValueError:\\n # Handle request without response here\\n pass\\n\\n rid += 1\\n\\n return frame_seq, fs_relation, all_stream\",\n \"def _split_forced(self, node):\\n # compute the split\\n _vec = 0\\n sorted_idxs = np.argsort(self.E[node.ids, _vec]).squeeze()\\n n = len(sorted_idxs) // 2\\n _lids = node.ids[sorted_idxs[:n]]\\n _rids = node.ids[sorted_idxs[n:]]\\n # compute the score of the new tubes only\\n _sl = self.get_tube_score(_lids)\\n _sr = self.get_tube_score(_rids)\\n # register the split\\n node.has_children = True\\n node.thresh = np.median(self.E[node.ids, _vec]) # arbitrary\\n # Note: median would not ensure equal size (because of duplicate values)\\n left = SpectralNode(_lids, _vec, score=_sl, name=node.name + \\\"0\\\")\\n right = SpectralNode(_rids, _vec, score=_sr, name=node.name + \\\"1\\\")\\n\\n return left, right\",\n \"def _semiconnected_ramps(slope1=1., slope2=1.) -> cs.Network:\\n\\n class _Ramp(cs.Simulator):\\n \\\"\\\"\\\"Used in tests to mock a simulator\\\"\\\"\\\"\\n def __init__(self, slope: Fraction, step_size: Fraction):\\n self._step_size = step_size\\n self._x = Fraction(0)\\n self._slope = slope\\n\\n @property\\n def inputs(self):\\n return {'u': sdf.InputPort(float, 1)}\\n\\n @property\\n def outputs(self):\\n return {'y': sdf.OutputPort(float, 1)}\\n\\n def calculate(self, input_tokens):\\n self._x += self._slope * self._step_size\\n return {'y': [float(self._x)]}\\n\\n def construct_ramp1(step_size):\\n return _Ramp(slope1, step_size)\\n\\n def construct_ramp2(step_size):\\n return _Ramp(slope2, step_size)\\n\\n slaves = {'Ramp1': construct_ramp1, 'Ramp2': construct_ramp2}\\n\\n connections = {\\n cs.Dst('Ramp1', 'u'): cs.Src('Ramp2', 'y'),\\n cs.Dst('Ramp2', 'u'): cs.Src('Ramp1', 'y'),\\n }\\n return slaves, connections\",\n \"def bfs(self, s):\\n g = Graph(attr={DIRECTED: True})\\n root = self.get_vertex(s)\\n root.attributes[DISCOVERED] = True\\n q = collections.deque()\\n adjacent_type = '+' if DIRECTED in self.attr and self.attr[\\n DIRECTED] else None\\n # Insert root node in graph and queue\\n g.add_vertex(root)\\n q.append(s)\\n\\n while (len(q) > 0):\\n v = q.popleft()\\n for e in self.get_adjacent_vertices_by_vertex(v, adjacent_type):\\n w = self.get_vertex(e)\\n if DISCOVERED not in w.attributes or w.attributes[\\n DISCOVERED] is False:\\n w.attributes[DISCOVERED] = True\\n q.append(w.id)\\n g.add_vertex(w)\\n g.add_edge(edge.Edge(v, e), True)\\n return g\",\n \"def a_star_alg(self, p1: int, p2: int, max_level: int = 1000):\\r\\n \\r\\n # Create start and end node\\r\\n start_node = Node(None, p1, self.node_dict[p1])\\r\\n start_node.g = start_node.h = start_node.f = 0\\r\\n end_node = Node(None, p2, self.node_dict[p2])\\r\\n end_node.g = end_node.h = end_node.f = 0\\r\\n\\r\\n # Initialize both open and closed list\\r\\n open_list = []\\r\\n closed_list = []\\r\\n\\r\\n # Add the start node\\r\\n open_list.append(start_node)\\r\\n\\r\\n # Loop until you find the end\\r\\n level = 0\\r\\n while len(open_list) > 0 and level < max_level:\\r\\n level += 1\\r\\n\\r\\n # Get the current node (the node in open_list with the lowest cost)\\r\\n current_node = open_list[0]\\r\\n current_index = 0\\r\\n for index, item in enumerate(open_list):\\r\\n if item.f < current_node.f:\\r\\n current_node = item\\r\\n current_index = index\\r\\n\\r\\n # Pop current off open list, add to closed list\\r\\n open_list.pop(current_index)\\r\\n closed_list.append(current_node)\\r\\n\\r\\n # Found the goal\\r\\n if current_node == end_node:\\r\\n path = []\\r\\n distance = current_node.g\\r\\n current = current_node\\r\\n while current is not None:\\r\\n path.append(current.number)\\r\\n current = current.parent\\r\\n\\r\\n return path[::-1], distance # Return reversed path\\r\\n\\r\\n # Generate children\\r\\n children = []\\r\\n for new_number in self.road_tree[current_node.number]: # Adjacent nodes\\r\\n new_node = Node(current_node, new_number, self.node_dict[new_number])\\r\\n children.append(new_node)\\r\\n\\r\\n # Loop through children\\r\\n for child in children:\\r\\n append_to_open_list = False\\r\\n\\r\\n # Create the f, g, and h values\\r\\n child.g = current_node.g + self.road_dict[(current_node.number, child.number)]\\r\\n child.h = sqrt((child.x - end_node.x) ** 2 + (child.y - end_node.y) ** 2) / 200\\r\\n child.f = child.g + child.h\\r\\n\\r\\n # Child is already in the closed list\\r\\n closed_list, append_to_open_list = self.check_in_list(child, closed_list, append_to_open_list)\\r\\n\\r\\n # Child is already in the open list\\r\\n open_list, append_to_open_list = self.check_in_list(child, open_list, append_to_open_list)\\r\\n\\r\\n # Add the child to the open list\\r\\n if append_to_open_list:\\r\\n open_list.append(child)\\r\\n\\r\\n return [], 1e10\",\n \"def find_all_cycles(s,graph):\\n\\n grph = u.edge_to_list_dict(graph)\\n node_cnt = len(grph)\\n k = z.Int(\\\"k\\\")\\n syms = [z.Int('node%s'%i) for i in range(node_cnt)]\\n\\n # s.add(syms[0] == 0) # start node is a 0\\n s.add(k < node_cnt)\\n s.add(k > 1)\\n\\n o = z.Optimize()\\n\\n # for source, sinks in sgraph.s_adj_list():\\n for i in range(node_cnt):\\n s.add(syms[i] >= 0)\\n s.add(syms[i] <= k)\\n s.add(z.Or([syms[j] == ((syms[i] + 1) % k) for j in grph[i]]) == (syms[i] == 0))\\n\\n\\n r = []\\n m = []\\n\\n # o.minimize(z.Sum([syms[i] for i in range(node_cnt)]))\\n s.add(z.Product([syms[i] for i in range(node_cnt)]) == 0)\\n done = False\\n while not done:\\n if s.check() == z.sat:\\n m = s.model()\\n r.append(m)\\n s.add(k != m[k])\\n else:\\n done = True\\n\\n return r\",\n \"def calc_lp(self, demands: Demand, routing: Routing) -> float:\\n epsilon = self.epsilon\\n\\n # Create the linear solver with the GLOP backend.\\n solver = pywraplp.Solver('flow_utilisation_lp',\\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\\n\\n ## VARIABLES\\n # Flow variables, the amount of flow along each edge\\n # stored as a list flow_variables[ith_flow][jth_edge]\\n flow_variables = []\\n for i in range(len(self.commodities)):\\n flow_variable_edges = []\\n for j in range(len(self.edges)):\\n flow_variable_edges.append(\\n solver.NumVar(0, solver.infinity(), '({},{})'.format(i, j)))\\n flow_variables.append(flow_variable_edges)\\n\\n ## CONSTRAINTS\\n # Flow from source constraint (net flow must equal demand)\\n conservation_source_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # create constraint\\n constraint_i = solver.Constraint(demands[i] - epsilon,\\n demands[i] + epsilon,\\n '(source,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[0])]:\\n # out flow is positive\\n constraint_i.SetCoefficient(flow_variables[i][edge_index], 1)\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[0])]:\\n # in flow is negative\\n constraint_i.SetCoefficient(flow_variables[i][edge_index], -1)\\n conservation_source_constraints.append(constraint_i)\\n\\n # Flow to sink constraint (in flow must equal demand, out must be zero)\\n conservation_sink_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # create in flow constraint\\n constraint_i_in = solver.Constraint(-demands[i] - epsilon,\\n -demands[i] + epsilon,\\n '(sink_in,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[1])]:\\n # in flow is negative\\n constraint_i_in.SetCoefficient(flow_variables[i][edge_index],\\n -1)\\n conservation_sink_constraints.append(constraint_i_in)\\n\\n constraint_i_out = solver.Constraint(0, 0,\\n '(sink_out,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[1])]:\\n # out flow is positive\\n constraint_i_out.SetCoefficient(flow_variables[i][edge_index],\\n 1)\\n conservation_sink_constraints.append(constraint_i_out)\\n\\n # Flow at transit node constraint (net flow must be zero)\\n conservation_transit_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.graph.number_of_nodes()):\\n if j != commodity[0] and j != commodity[1]:\\n # create constraint\\n constraint_j = solver.Constraint(-epsilon, +epsilon,\\n '(transit,{},{})'.format(i,\\n j))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(j)]:\\n # out flow is positive\\n constraint_j.SetCoefficient(\\n flow_variables[i][edge_index],\\n 1)\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(j)]:\\n # in flow is negative\\n constraint_j.SetCoefficient(\\n flow_variables[i][edge_index],\\n -1)\\n constraints_flow_i.append(constraint_j)\\n conservation_transit_constraints.append(constraints_flow_i)\\n\\n # Flow splitting at transit constraints (edge flow must be correct split of\\n # in flow)\\n splitting_ratio_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.graph.number_of_nodes()):\\n # Sink has not such constraint and we handle source differently\\n if j != commodity[1] and j != commodity[0]:\\n in_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(j)]\\n out_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(j)]\\n\\n # separate constraint for split of each out_edge taking into\\n # account all in_edges\\n for out_edge_index in out_edges:\\n # create constraint\\n constraint_edge = \\\\\\n solver.Constraint(-epsilon, +epsilon,\\n '(split,{},{},{})'.format(\\n i, j,\\n out_edge_index))\\n split_ratio = routing[i][out_edge_index]\\n # flow on out edge\\n constraint_edge.SetCoefficient(\\n flow_variables[i][out_edge_index], 1)\\n for in_edge_index in in_edges:\\n # should equal sum of flow on all in edges scaled by\\n # split ratio\\n constraint_edge.SetCoefficient(\\n flow_variables[i][in_edge_index],\\n -1 * split_ratio)\\n constraints_flow_i.append(constraint_edge)\\n splitting_ratio_constraints.append(constraints_flow_i)\\n\\n # Flow splitting at source constraints (edge flow must be correct split of\\n # in flow + demand)\\n source_splitting_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n in_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[0])]\\n out_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[0])]\\n for out_edge_index in out_edges:\\n # create constraint\\n split_ratio = routing[i][out_edge_index]\\n split_demand = split_ratio * demands[i]\\n constraint_edge = \\\\\\n solver.Constraint(split_demand - epsilon,\\n split_demand + epsilon,\\n '(split,{},{},{})'.format(i, j,\\n out_edge_index))\\n # flow on out edge\\n constraint_edge.SetCoefficient(\\n flow_variables[i][out_edge_index], 1)\\n for in_edge_index in in_edges:\\n # should equal sum of flow on all in edges scaled by split ratio\\n constraint_edge.SetCoefficient(\\n flow_variables[i][in_edge_index],\\n -1 * split_ratio)\\n constraints_flow_i.append(constraint_edge)\\n source_splitting_constraints.append(constraints_flow_i)\\n\\n solver.Solve()\\n\\n result_status = solver.Solve()\\n\\n utilisation = np.zeros(\\n (len(self.commodities), self.graph.number_of_edges()))\\n # # extract the actual routing. Useful for debugging, maybe use to bootstrap\\n # assignment = np.zeros(\\n # (len(self.commodities), self.graph.number_of_edges()))\\n\\n # if routing is really that bad, just bail and give a sad result\\n if result_status == solver.NOT_SOLVED or result_status == solver.INFEASIBLE:\\n return 1.0\\n\\n for i in range(len(self.commodities)):\\n for j in range(self.graph.number_of_edges()):\\n utilisation[i][j] = flow_variables[i][j].solution_value() / \\\\\\n self.edges[j][2]['weight']\\n # assignment[i][j] = flow_variables[i][j].solution_value()\\n\\n return np.max(np.sum(utilisation, axis=0))\",\n \"def bfs(self) -> dict:\\n distances_graph = {}\\n\\n # BFS from middle to the robot start point\\n start = self.center\\n search = self.start\\n\\n distances_graph[start] = 0\\n queue = collections.deque([start])\\n\\n while True:\\n # Get next node\\n node = queue.pop()\\n\\n if node == search:\\n # If this is the one we need, search no more\\n break\\n\\n for neighbor in self.graph[node]:\\n if neighbor not in distances_graph:\\n # If distance to neighbor hasn't been calculated, calculate it\\n queue.appendleft(neighbor)\\n distances_graph[neighbor] = distances_graph[node] + 1\\n\\n return distances_graph\",\n \"def setup_nodes(server_node, road_node, road_segment_point):\\n\\n # Create working server node data subset excluding unneeded fields\\n snode = [{'id': i,\\n 'shapeid': item['shapeid'],\\n 'x': float(item['x']),\\n 'y': float(item['y']),\\n 'nearest_pt': None,\\n 'nearest_pt_sl_dist': float(\\\"inf\\\"),\\n 'color_num': (int(item['shapeid']) + CM_OFFSET) % NUM_COLORS}\\n for i, item in enumerate(server_node)]\\n\\n # Create working road node data subset excluding unneeded fields\\n # (note: road nodes consist of junctions and road ends)\\n rnode = []\\n prev_coord = []\\n for i, item in enumerate(road_node):\\n if [item['x'], item['y']] not in prev_coord: # exclude duplicates\\n rnode.append({'id': i,\\n 'shapeid': item['shapeid'],\\n 'x': float(item['x']),\\n 'y': float(item['y']),\\n 'best_server': None,\\n 'color_num': GREY})\\n prev_coord.append([item['x'], item['y']])\\n\\n # Create working road point data subset excluding unneeded fields\\n rpoint = []\\n point = 0\\n for i in range(len(road_segment_point)):\\n id = road_segment_point[i]['shapeid']\\n rpoint.append({'id': i,\\n 'shapeid': id,\\n 'point': point,\\n 'x': float(road_segment_point[i]['x']),\\n 'y': float(road_segment_point[i]['y']),\\n 'lowest_cost': float(\\\"inf\\\"),\\n 'best_server': None,\\n 'color_num': GREY})\\n if i < len(road_segment_point) - 1:\\n id_next = road_segment_point[i + 1]['shapeid']\\n if id == id_next:\\n point += 1\\n else:\\n point = 0\\n\\n # Convert adjacent road segment endpoints to lines (x1, y1) to (x2, y2)\\n rseg = []\\n line = 0\\n seg = 0\\n for i in range(len(rpoint[:-1])):\\n id = rpoint[i]['shapeid']\\n id_next = rpoint[i + 1]['shapeid']\\n if id == id_next:\\n rseg.append({'id': line,\\n 'shapeid': id,\\n 'segment': seg,\\n 'point1': rpoint[i]['id'],\\n 'x1': float(rpoint[i]['x']),\\n 'y1': float(rpoint[i]['y']),\\n 'point2': rpoint[i + 1]['id'],\\n 'x2': float(rpoint[i + 1]['x']),\\n 'y2': float(rpoint[i + 1]['y']),\\n 'best_server': None,\\n 'color_num': GREY})\\n line += 1\\n seg += 1\\n else:\\n seg = 0\\n\\n return snode, rnode, rpoint, rseg\",\n \"def routes(self) -> List[Tuple[int, bytes]]:\\n raise NotImplementedError() # pragma: no cover\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69459766","0.5595106","0.5534561","0.5483686","0.54691195","0.5467508","0.53494895","0.53470665","0.53366846","0.53234804","0.5310389","0.52716064","0.52382374","0.5235263","0.52303815","0.5227401","0.52202076","0.5218126","0.5190948","0.51826143","0.51786155","0.51763994","0.5171623","0.5167743","0.51458013","0.5132611","0.5119417","0.5104868","0.5102928","0.50998455","0.50978696","0.50748396","0.506639","0.50428355","0.5039313","0.50376946","0.50372684","0.5030104","0.5024697","0.5012385","0.50081164","0.5003986","0.50007343","0.49962327","0.49893022","0.4984923","0.49784076","0.4975981","0.4974546","0.4974474","0.49737376","0.49712655","0.4968011","0.49635297","0.495627","0.49558866","0.49395913","0.49275103","0.49133584","0.49070454","0.4903396","0.49031207","0.48845205","0.48772913","0.48620522","0.48612422","0.4860135","0.48584878","0.4854796","0.48546422","0.48519534","0.48405495","0.48369002","0.48356608","0.48340955","0.4826039","0.48199221","0.48196697","0.4817052","0.48168376","0.48133653","0.48067635","0.48060665","0.48059827","0.48029354","0.4799735","0.47980908","0.47946438","0.4793901","0.47849047","0.4784174","0.47812286","0.47802192","0.4779466","0.4776442","0.47717482","0.4770857","0.47643498","0.47633645"],"string":"[\n \"0.69459766\",\n \"0.5595106\",\n \"0.5534561\",\n \"0.5483686\",\n \"0.54691195\",\n \"0.5467508\",\n \"0.53494895\",\n \"0.53470665\",\n \"0.53366846\",\n \"0.53234804\",\n \"0.5310389\",\n \"0.52716064\",\n \"0.52382374\",\n \"0.5235263\",\n \"0.52303815\",\n \"0.5227401\",\n \"0.52202076\",\n \"0.5218126\",\n \"0.5190948\",\n \"0.51826143\",\n \"0.51786155\",\n \"0.51763994\",\n \"0.5171623\",\n \"0.5167743\",\n \"0.51458013\",\n \"0.5132611\",\n \"0.5119417\",\n \"0.5104868\",\n \"0.5102928\",\n \"0.50998455\",\n \"0.50978696\",\n \"0.50748396\",\n \"0.506639\",\n \"0.50428355\",\n \"0.5039313\",\n \"0.50376946\",\n \"0.50372684\",\n \"0.5030104\",\n \"0.5024697\",\n \"0.5012385\",\n \"0.50081164\",\n \"0.5003986\",\n \"0.50007343\",\n \"0.49962327\",\n \"0.49893022\",\n \"0.4984923\",\n \"0.49784076\",\n \"0.4975981\",\n \"0.4974546\",\n \"0.4974474\",\n \"0.49737376\",\n \"0.49712655\",\n \"0.4968011\",\n \"0.49635297\",\n \"0.495627\",\n \"0.49558866\",\n \"0.49395913\",\n \"0.49275103\",\n \"0.49133584\",\n \"0.49070454\",\n \"0.4903396\",\n \"0.49031207\",\n \"0.48845205\",\n \"0.48772913\",\n \"0.48620522\",\n \"0.48612422\",\n \"0.4860135\",\n \"0.48584878\",\n \"0.4854796\",\n \"0.48546422\",\n \"0.48519534\",\n \"0.48405495\",\n \"0.48369002\",\n \"0.48356608\",\n \"0.48340955\",\n \"0.4826039\",\n \"0.48199221\",\n \"0.48196697\",\n \"0.4817052\",\n \"0.48168376\",\n \"0.48133653\",\n \"0.48067635\",\n \"0.48060665\",\n \"0.48059827\",\n \"0.48029354\",\n \"0.4799735\",\n \"0.47980908\",\n \"0.47946438\",\n \"0.4793901\",\n \"0.47849047\",\n \"0.4784174\",\n \"0.47812286\",\n \"0.47802192\",\n \"0.4779466\",\n \"0.4776442\",\n \"0.47717482\",\n \"0.4770857\",\n \"0.47643498\",\n \"0.47633645\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7221145"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":24593,"cells":{"query":{"kind":"string","value":"RETURNS A set of outgoing links and corresponding splitting ratios for flow f at node s"},"document":{"kind":"string","value":"def get_paths_for_flow(F, s, f):\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links"},"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 traverse_graph(F, f, s, t, u, sr):\n def get_paths_for_flow(F, s, f):\n \"\"\"\n RETURNS\n A set of outgoing links and corresponding splitting ratios for flow f\n at node s\n \"\"\"\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links\n \n if u == t:\n return [([t], sr)]\n\n outgoing_links = get_paths_for_flow(F, u, f)\n paths_to_t = []\n\n for ((current_node, next_hop), split_ratio) in outgoing_links:\n paths_from_u_to_t = traverse_graph(F, f, s, t, next_hop, split_ratio) \n paths_to_t.extend(paths_from_u_to_t)\n\n paths_to_t_with_u = []\n for path in paths_to_t:\n nodes, sr = path\n new_path = [u] + nodes\n paths_to_t_with_u.append((new_path, sr))\n\n return paths_to_t_with_u","def step(nodes, outputs, edges):\n flowed = []\n for node_name in nodes.copy():\n if node_name in flowed:\n continue\n if len(nodes[node_name]) == 2:\n if node_name in flowed:\n continue\n node = [int(value) for value in nodes[node_name]]\n low_value, high_value = min(node), max(node)\n low_flow, high_flow = edges[node_name] \n low_dictionary, low_node_name = low_flow\n high_dictionary, high_node_name = high_flow\n low_node = low_dictionary.get(low_node_name, tuple())\n high_node = high_dictionary.get(high_node_name, tuple())\n low_dictionary[low_node_name] = low_node + (str(low_value),)\n high_dictionary[high_node_name] = high_node + (str(high_value),)\n nodes[node_name] = tuple()\n if low_dictionary is nodes:\n flowed.append(low_node_name)\n if high_dictionary is nodes:\n flowed.append(high_node_name)\n return nodes, outputs, edges","def split_at_nodes(shp):\n nodes = find_nodes(shp)\n nodeIds = list(nodes)\n nodeIds.sort()\n nodeIds = dict([(node,i) for i,node in enumerate(nodeIds)])\n \n for road in shp:\n vrts = road.vertices\n midVrts = set(road.vertices[1:-1]) #we know end points are nodes\n midNodes = midVrts.intersection(nodes) # find any nodes in the middle of the feature.\n midIdx = [vrts.index(node) for node in midNodes] # Get their indices\n midIdx.sort()\n if midIdx:\n #print vrts\n starts = [0]+midIdx\n stops = [x+1 for x in midIdx]+[None]\n for start,stop in zip(starts,stops):\n feat = pysal.cg.Chain(vrts[start:stop])\n rec = (nodeIds[feat.vertices[0]],nodeIds[feat.vertices[-1]],False)\n yield feat,rec\n else:\n rec = (nodeIds[road.vertices[0]],nodeIds[road.vertices[-1]],False)\n yield road,rec","def _split(self):\r\n \r\n temp = [self.upstream.demand]\r\n for item, p in zip(self.downstream, self.priority):\r\n temp.append(item.supply/p)\r\n \r\n flow = min(temp) # total flow\r\n \r\n self.upstream.outflow = flow\r\n \r\n for item, p in zip(self.downstream, self.priority):\r\n item.inflow = p * flow","def ford_fulkerson_algorithm(graph: np.ndarray, source: int, sink: int) -> np.ndarray:\r\n\r\n residual_graph = copy.deepcopy(graph)\r\n row = len(residual_graph)\r\n parent = [-1] * row\r\n max_flow = 0\r\n\r\n if source == sink or sink < 0 or source < 0 or source >= row or sink >= row:\r\n raise WrongInputException('Wrong input source/sink vertice(s)')\r\n\r\n while bfs(residual_graph, row, source, sink, parent):\r\n\r\n path_flow = float(\"Inf\")\r\n s = sink\r\n while s != source:\r\n path_flow = min(path_flow, residual_graph[parent[s]][s])\r\n s = parent[s]\r\n\r\n max_flow += path_flow\r\n\r\n v = sink\r\n while v != source:\r\n u = parent[v]\r\n residual_graph[u][v] -= path_flow\r\n residual_graph[v][u] += path_flow\r\n v = parent[v]\r\n print(\"Max flow: %d\" % max_flow)\r\n\r\n return residual_graph","def split_edges(self, maximum_distance):\n \"\"\" Iterate through the vertices of each section. For each vertex v, evaluate edges for which v is a source.\n If an edge of weight greater than maximum_distance, then split it. \"\"\"\n for section_id in self.sections:\n utils.print_progress(len(self.sections), prefix='splitting edges')\n current_section = [] # Need to update the section data after splitting the edges.\n for source in self.sections[section_id]:\n current_section.append(source)\n edges_to_remove = [] # If an edge is split, it will need to be removed.\n for edge in self.graph.get_out_edges(source):\n if self.edge_weights[edge] > maximum_distance:\n target = edge[1] # edge is a numpy array of [source, target, edge]. Select target.\n edges_to_remove.append(self.graph.edge(edge[0], edge[\n 1])) # If an edge is split, the original edge should be removed.\n\n new_edge_count = int(math.ceil(self.edge_weights[edge] / maximum_distance))\n new_edge_distance = self.edge_weights[edge] / new_edge_count\n current_point = shapes.Point.from_list(\n list(self.node_locations[source]) + [self.node_heading[target]])\n previous_vertex = source\n for _ in range(new_edge_count):\n current_point = utils.offset_point(current_point, new_edge_distance, current_point.bearing)\n current_vertex = self.graph.add_vertex()\n current_section.append(current_vertex) # The new vertex becomes a part of the section.\n \"\"\" Populate the property map for the new vertex. Inherit values from the target node,\n unless the target node is a junction node. Then inherit values from the source. \"\"\"\n self.node_locations[current_vertex] = current_point.as_list()\n self.node_heading[current_vertex] = current_point.bearing\n property_vertex = source if not self.junctions[target] else target\n self.node_speed_limit[current_vertex] = self.node_speed_limit[property_vertex]\n self.node_width[current_vertex] = self.node_width[property_vertex]\n self.node_id[current_vertex] = self.node_id[property_vertex]\n\n \"\"\" Create an edge between the previous vertex and the newly created vertex, \n and update the edge weight property map. \"\"\"\n current_edge = self.graph.add_edge(previous_vertex, current_vertex)\n self.edge_weights[current_edge] = new_edge_distance\n\n # The current vertex becomes the previous vertex in the next step.\n previous_vertex = current_vertex\n\n \"\"\" Create an edge between the last new vertex that was created and the target of the\n original edge which is being split, and update the property map. \"\"\"\n self.edge_weights[self.graph.add_edge(previous_vertex, target)] = new_edge_distance\n list(map(self.graph.remove_edge, edges_to_remove)) # Remove all relevant edges\n self.sections[section_id] = current_section # Update the section with the new vertices","def dfs(x, p, step):\n disc[x] = low[x] = step\n for xx in graph.get(x, []): \n if disc[xx] == inf: \n step += 1\n dfs(xx, x, step)\n low[x] = min(low[x], low[xx])\n if low[xx] > disc[x]: ans.append([x, xx]) # bridge\n elif xx != p: low[x] = min(low[x], disc[xx])","def get_flow_2frames(self, x):\n b, n, c, h, w = x.size()\n x_1 = x[:, :-1, :, :, :].reshape(-1, c, h, w)\n x_2 = x[:, 1:, :, :, :].reshape(-1, c, h, w)\n flows_backward = self.spynet(x_1, x_2)\n flows_backward = [flow.view(b, n - 1, 2, h // 2 ** i, w // 2 ** i) for flow, i in zip(flows_backward, range(4))]\n flows_forward = self.spynet(x_2, x_1)\n flows_forward = [flow.view(b, n - 1, 2, h // 2 ** i, w // 2 ** i) for flow, i in zip(flows_forward, range(4))]\n return flows_backward, flows_forward","def sg_hops (self):\n return (link for s, d, link in self.network.edges_iter(data=True) if\n link.type == Link.SG)","def compute_greedy_flow_allocations( target_graph\n , flow_selection_fn\n , seed_number=DEFAULT_SEED_NUMBER):\n\n flow_allocation_seed_number = seed_number\n np.random.seed(flow_allocation_seed_number)\n\n link_utilization = {tuple(sorted(link_tuple)): 0.0 for link_tuple in target_graph.edges}\n flows = []\n\n while True:\n capacity_was_exceeded = False\n\n source_node, destination_node = flow_selection_fn(target_graph.nodes)\n flow_tx_rate = np.random.uniform(FLOW_TX_RATE_LOWER_BOUND, FLOW_TX_RATE_UPPER_BOUND)\n\n connecting_paths = list(node_disjoint_paths(target_graph, source_node, destination_node))\n disjoint_path_count = len(connecting_paths)\n flow_rate_per_subpath = flow_tx_rate / disjoint_path_count\n for path in [nx.utils.pairwise(p_i) for p_i in connecting_paths]:\n for u, v in [tuple(sorted(t_i)) for t_i in path]:\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\n capacity_was_exceeded = True\n break\n link_utilization[u, v] += flow_rate_per_subpath\n if capacity_was_exceeded:\n break\n if capacity_was_exceeded:\n break\n\n the_flow = Flow( source_node = source_node\n , destination_node = destination_node\n , flow_tx_rate = flow_tx_rate\n , paths = connecting_paths\n , splitting_ratio = [1.0/disjoint_path_count]*disjoint_path_count\n )\n flows.append(the_flow)\n return flows, link_utilization","def compute_flow(self, lqs):\n n, t, c, h, w = lqs.size()\n lqs_1 = lqs[:, :-1, :, :, :].reshape(-1, c, h, w)\n lqs_2 = lqs[:, 1:, :, :, :].reshape(-1, c, h, w)\n flows_backward = self.spynet(lqs_1, lqs_2).view(n, t - 1, 2, h, w)\n if self.is_mirror_extended:\n flows_forward = None\n else:\n flows_forward = self.spynet(lqs_2, lqs_1).view(n, t - 1, 2, h, w)\n return flows_forward, flows_backward","def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\n demand: float,\n routing: np.ndarray) -> np.ndarray:\n edge_mapping = {edge: i for i, edge in\n enumerate(sorted(self.graph.edges))}\n\n link_utilisation = np.zeros(self.num_edges)\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\n node_flow[flow[0]] = demand\n\n to_explore = [flow[0]]\n while to_explore:\n current_node = to_explore.pop(0)\n current_flow = node_flow[current_node]\n\n # this is the flow destination node so we absorb all flow\n if current_node == flow[1]:\n node_flow[current_node] = 0.0\n continue\n\n # push the flow at this node over all edges\n for edge in self.graph.out_edges(current_node):\n edge_index = edge_mapping[edge]\n ratio = routing[edge_index]\n flow_to_send = ratio * current_flow\n # only send flow if greater than epsilon (so no 'infinite' loops)\n if flow_to_send > 1.e-8:\n node_flow[edge[1]] += ratio * current_flow\n # all important step, update our output\n link_utilisation[edge_index] += ratio * current_flow\n # have updated the dst so add it to the list of things to do\n to_explore.append(edge[1])\n # we've moved all the flow from this node now, so reset back to zero\n node_flow[current_node] = 0.0\n\n return link_utilisation","def DRBFS(self, flow, edge_mark):\n\t\t# Distance flag for each node\n\t\td = {v:float('inf') for v in self.topo.nodes}\n\t\t# Parent node for each node\n\t\tpa = {v:-1 for v in self.topo.nodes}\n\t\t# Request info\n\t\ts = flow[0]\n\t\tt = flow[1]\n\n\t\t# BFS to find a min-hop path\n\t\tqueue = [s]; hdr = 0; d[s] = 0\n\t\twhile hdr < len(queue):\n\t\t\tu = queue[hdr]\n\t\t\thdr += 1\n\n\t\t\tfor v in self.topo.topo.neighbors(u):\n\t\t\t\tif edge_mark[(u, v)] or d[v] <= d[u] + 1:\n\t\t\t\t\tcontinue\n\t\t\t\tqueue.append(v)\n\t\t\t\td[v] = d[u] + 1\n\t\t\t\tpa[v] = u\n\t\t\t\tif v == t:\n\t\t\t\t\t# This is because when BFS on edges, the first time reaching t meaning the smallest hop it can be reached\n\t\t\t\t\thdr = len(queue)\n\t\t\t\t\tbreak\n\n\t\tif d[t] == float('inf'):\n\t\t\treturn False\n\n\t\tp = [t]; v = t\n\t\twhile v != s and v != -1:\n\t\t\tv = pa[v]\n\t\t\tp.append(v)\n\t\tp.reverse()\n\n\t\treturn p","def get_all_sghop_info (nffg, return_paths=False):\n sg_map = {}\n for i in nffg.infras:\n for p in i.ports:\n for fr in p.flowrules:\n # if fr.external:\n # continue\n if fr.id not in sg_map:\n # The path is unordered!!\n path_of_shop = []\n flowclass = NFFGToolBox._extract_flowclass(fr.match.split(\";\"))\n sg_map[fr.id] = [None, None, flowclass, fr.bandwidth, fr.delay]\n # We have to find the BEGINNING of this flowrule sequence.\n inbound_link = NFFGToolBox._find_infra_link(nffg, p, outbound=False,\n accept_dyn=True)\n while inbound_link.type != 'DYNAMIC':\n path_of_shop.append(inbound_link)\n if inbound_link.src.node.type == 'SAP':\n break\n # The link is STATIC, and its src is not SAP so it is an Infra.\n prev_fr, prev_p = \\\n NFFGToolBox._get_flowrule_and_its_starting_port(\n inbound_link.src.node, fr.id)\n NFFGToolBox._check_flow_consistencity(sg_map, prev_fr)\n inbound_link = NFFGToolBox._find_infra_link(nffg, prev_p,\n outbound=False,\n accept_dyn=True)\n # 'inbound_link' is DYNAMIC here or it is STATIC and starts from\n # a SAP,\n # so the sequence starts here\n sg_map[fr.id][0] = inbound_link.src\n\n # We have to find the ENDING of this flowrule sequence.\n output_port = NFFGToolBox._get_output_port_of_flowrule(i, fr)\n if output_port is None:\n continue\n outbound_link = NFFGToolBox._find_infra_link(nffg, output_port,\n outbound=True,\n accept_dyn=True)\n while outbound_link.type != 'DYNAMIC':\n path_of_shop.append(outbound_link)\n if outbound_link.dst.node.type == 'SAP':\n break\n # The link is STATIC and its dst is not a SAP so it is an Infra.\n next_fr, _ = NFFGToolBox._get_flowrule_and_its_starting_port(\n outbound_link.dst.node, fr.id)\n # '_' is 'outbound_link.dst'\n next_output_port = NFFGToolBox._get_output_port_of_flowrule(\n outbound_link.dst.node, next_fr)\n NFFGToolBox._check_flow_consistencity(sg_map, next_fr)\n outbound_link = NFFGToolBox._find_infra_link(nffg,\n next_output_port,\n outbound=True,\n accept_dyn=True)\n # the 'outbound_link' is DYNAMIC here or finishes in a SAP, so the\n # flowrule sequence finished here.\n sg_map[fr.id][1] = outbound_link.dst\n\n if return_paths:\n sg_map[fr.id].append(path_of_shop)\n\n return sg_map","def routes_for_od(self, r, s):\n\n for path in self.paths_for_od(r, s):\n route = self._road_network.network.copy()\n\n for edge in route.edges_iter():\n u,v = edge\n if BaseRouter._edge_in_path(path, edge):\n route.edge[u][v]['pathweight'] = 0.1\n else:\n route.edge[u][v]['pathweight'] = 1.0\n\n # Set node weights\n for node in route:\n try:\n dist_from_path = nx.shortest_path_length(route,\n node,\n path[-1],\n weight='pathweight')\n except nx.NetworkXNoPath:\n dist_from_path = float('inf')\n\n route.node[node]['weight'] = math.exp(-self._beta*dist_from_path)\n\n \n # Create policy from weights\n def edge_weight(u,v):\n return route.node[v]['weight']*math.exp(\n -self._beta*route.edge[u][v]['pathweight'])\n\n for node in route:\n edges = route.edges(node)\n total_edge_weight = reduce(\n lambda x,y: x+y,\n [edge_weight(u,v) for u,v in edges],\n 0.0)\n\n for u,v in edges:\n route[u][v]['weight'] = \\\n edge_weight(u, v) / float(total_edge_weight)\n\n yield Route(route, path)","def dfs_r(self, s):\n g = Graph(attr={DIRECTED: True})\n return self.dfs_rec(g, ('#', s))","def distribute(node, rank_links):\n r = rank_links[0]\n links = rank_links[1]\n\n ol = str(links).split('|')\n Ni = len(ol)\n\n # if the node is for dangling (i.e. no outgoing link),\n # emit the loss to redistribute to all the incoming\n # links to the dangling node\n if (Ni == 1 and ol[0] == '') or Ni == 0:\n yield 'DANGLING', r\n else:\n r_new = float(r)/float(Ni)\n for l in ol:\n yield l, r_new\n\n # recover graph structure\n if links <> '':\n yield node, links","def update_flow(self):\n start_nodes = []\n end_nodes = []\n capacities = []\n # (1): add all edges (u, v) with capacity ub-lb\n B = self.get_max_lb()*(self.num_edges() - len(self) + 2)\n for arc in self.arc_info.keys():\n if self.arc_info[arc][\"upper_bound\"] == float('inf'):\n self.arc_info[arc][\"upper_bound\"] = B\n for arc in self.arc_info.keys():\n start_nodes.append(self.arc_info[arc][\"start\"])\n end_nodes.append(self.arc_info[arc][\"destin\"])\n capacities.append(int(self.arc_info[arc][\"upper_bound\"]\\\n - self.arc_info[arc][\"lower_bound\"]))\n # (2): add edge (t, s) with capacity B\n # B = max_lb * (m - n + 2)\n B = self.get_max_lb()*(self.num_edges() - len(self) + 2)\n if B == 0:\n #B = float('inf')\n B = 100000\n start_nodes.append(self.sink())\n end_nodes.append(self.source())\n capacities.append(int(B))\n # (3): for all verts, if exc > 0, add edge (s', v) with capacity exc(v),\n # and if exc < 0, add edge(s', v) with capacity -exc(v)\n s_prime = max(self.vertices) + 1\n t_prime = max(self.vertices) + 2\n print(\"s'={}, t'={}\".format(s_prime, t_prime))\n for v in self:\n #print(\"vert {} in arcs: {}\".format(v,\n # self.in_arcs_lists[v]))\n # compute exc: lower bounds of in - lower bounds of out\n sum_lb_in = 0\n for in_arc in self.in_arcs_lists[v]:\n sum_lb_in += self.arc_info[in_arc][\"lower_bound\"]\n sum_lb_out = 0\n #print(\"vert {} out arcs: {}\".format(v,\n # self.out_arcs_lists[v]))\n for out_arc in self.out_arcs_lists[v]:\n sum_lb_out += self.arc_info[out_arc][\"lower_bound\"]\n exc = sum_lb_in - sum_lb_out\n #print(\"exc is {}\".format(exc))\n if exc > 0:\n start_nodes.append(s_prime)\n end_nodes.append(v)\n capacities.append(int(exc))\n else:\n start_nodes.append(v)\n end_nodes.append(t_prime)\n capacities.append(int(-exc))\n # solve maxflow\n #print(\"s' is {} and t' is {}\".format(s_prime, t_prime))\n max_flow = pywrapgraph.SimpleMaxFlow()\n for u, v, cap in zip(start_nodes, end_nodes, capacities):\n #print(\"Adding edge {}, {} with cap {}\".format(u,v,cap))\n max_flow.AddArcWithCapacity(u, v, cap)\n success = True\n if max_flow.Solve(s_prime, t_prime) == max_flow.OPTIMAL:\n #print('Max flow: {}'.format( max_flow.OptimalFlow()))\n #print(' Arc Flow / Capacity')\n for i in range(max_flow.NumArcs()):\n # print('%1s -> %1s %3s / %3s' % (\n # max_flow.Tail(i),\n # max_flow.Head(i),\n # max_flow.Flow(i),\n # max_flow.Capacity(i)))\n # check that (s', v) edges are saturated (once we find a false,\n # stay false forever)\n if success:\n if max_flow.Tail(i) == s_prime:\n success = max_flow.Flow(i) == max_flow.Capacity(i)\n else:\n success = False\n print('There was an issue with the max flow input.')\n if success:\n # update the flows to be the flow found from maxflow problem\n for i in range(max_flow.NumArcs()):\n # if this is an original arc, update the flow\n if max_flow.Tail(i) != s_prime \\\n and max_flow.Head(i) != t_prime \\\n and not (max_flow.Tail(i) == self.sink() \\\n and max_flow.Head(i) == self.source()):\n # update arc\n start = max_flow.Tail(i)\n destin = max_flow.Head(i)\n arc = self.get_arc(start, destin)\n new_flow = self.arc_info[arc][\"lower_bound\"] + max_flow.Flow(i)\n old_flow = self.arc_info[arc][\"weight\"]\n self.arc_info[arc][\"weight\"] = new_flow\n #print(\"Edge {} {} adjusted from {} to {}\".format(\n # start,\n # destin,\n # old_flow,\n # new_flow\n # ))\n self.check_conservation_of_flow() # check that solution is valid\n return True\n else:\n return False","def findPathsToBase(A,bSize):\n M,N = A.shape\n pressedPaths = []\n\n #For every two nodes in the base find all paths between them\n for b1 in range(bSize):\n for b2 in range(bSize):\n #Remove all other base nodes from the graph so that\n #we only find paths that go through the specialization set\n if b1 == b2:\n #In this case we are looking for a cycle.\n mask = [b1]+list(range(bSize,N))\n newSize = len(mask) + 1\n reduA = np.zeros((newSize,newSize))\n #Because the networkx cycle finders don't do what we need\n #them to do, we create a new graph and find paths instead\n reduA[:-1,:-1] = A[mask,:][:,mask]\n #Remove ingoing edges from the base node and add to new node\n reduA[-1,:] = reduA[0,:]\n reduA[0,:] = np.zeros(newSize)\n G = nx.DiGraph(reduA.T)\n #Find paths from the base node to the new node\n #same as finding all the cycles\n paths = list(nx.all_simple_paths(G,0,newSize-1))\n\n else:\n mask = [b1,b2]+list(range(bSize,N))\n reduA = A[mask,:][:,mask]\n #Remove base node interactions\n reduA[:2,:2] = np.zeros((2,2))\n G = nx.DiGraph(reduA.T)\n paths = list(nx.all_simple_paths(G,0,1))\n\n #Process Paths so that they make sense when the rest of the base\n #set is added to the graph\n for p in paths:\n if p != []:\n if b1 == b2:\n p = np.array(p) + bSize-1\n else:\n p = np.array(p) + bSize-2\n p[[0,-1]] = [b1, b2]\n pressedPaths.append(p)\n\n return pressedPaths","def compute_half_life_vested_shares(params, step, sL, s, inputs):\n key = 'delegators'\n \n delegators = s['delegators']\n\n half_life_vesting_rate = params['half_life_vesting_rate']\n \n for delegator in delegators.values():\n # for future computation speed, vest them in chunks, it doesn't matter which chunk\n shares_vesting_this_period = delegator.unvested_shares * half_life_vesting_rate\n for timestep in delegator._unvested_shares:\n remaining_shares_to_vest = shares_vesting_this_period\n if delegator._unvested_shares[timestep] > remaining_shares_to_vest:\n delegator._unvested_shares[timestep] -= remaining_shares_to_vest\n break\n else:\n # 0 out and go onto the next one\n remaining_shares_to_vest -= delegator._unvested_shares[timestep]\n delegator._unvested_shares[timestep] = 0\n \n delegator.vested_shares += shares_vesting_this_period\n # print(f'{delegator.vested_shares=}, {delegator.unvested_shares=}, {delegator.shares=}')\n value = delegators\n\n return key, value","def dfs_traversal(graph, s, goals=[]):\n visited = []\n boundary = [s]\n while len(boundary) > 0:\n v = boundary.pop()\n visited += [v]\n if v in goals:\n return visited\n for w in neighbours(v, graph):\n if w not in visited and w not in boundary:\n boundary.append(w)\n return visited\n\n \"\"\"\n visited = []\n boundary = [s]\n while len(boundary) > 0:\n v = boundary.pop()\n visited += [v]\n for w in neighbours(v, graph):\n if w not in visited and w not in boundary:\n boundary.append(w)\n if w in goals:\n v = boundary.pop()\n visited += [v]\n return visited\n\"\"\"","def get_dfs(self, s):\n results = []\n # mark all the vertices as not visited\n visited = [False] * (len(self.graph))\n self._dfs_recursive(s, visited, results)\n return results","def bfs(g: nx.Graph, start_node: Hashable) -> List[Hashable]:\n list_ = list(g.neighbors(start_node))\n len_graph = g.number_of_nodes()\n list2 = [start_node]\n while len(list2) < len_graph:\n for i in range(len(list_) - 1):\n if list_[0] not in list2:\n list2.append(list_[0])\n list_ += list(g.neighbors(list_[0]))\n list_.remove(list_[0])\n # nx.draw(g, with_labels=True)\n # plt.show()\n return list2","def flowingFrom(self, fount):","def hmn2(a, s, m0):\n n = 2*m0**s\n links = np.zeros((int(a/m0*n*sum([1/2**x for x in range(1, s+1)])), 2), dtype=np.int32)\n links_i = 0\n p = 0\n \n # At each hierarchy level a number of a links are established,\n # repeating the process if links are repeated.\n for si in range(1, s+1):\n m0_si = m0**si\n for n in range(0, n+1-2*m0_si, 2*m0_si):\n \n if a == 1:\n i = np.random.randint(0 + n, m0_si + n)\n j = np.random.randint(m0_si + n, 2*m0_si + n)\n links[p] = np.array([i, j])\n p += 1\n \n else:\n while len(np.unique(links[links_i:a + links_i], axis=0)) != a:\n for m in range(a):\n i = np.random.randint(0 + n, m0_si + n)\n j = np.random.randint(m0_si + n, 2*m0_si + n)\n links[links_i:a + links_i][m] = np.array([i, j])\n links_i += a\n \n blocks = np.arange(n).reshape((int(n/m0), m0))\n return np.concatenate((blocks, links))","def destination_floors(self):\r\n return self.destinations","def compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\n logger.debug(f\"comparing {node1},{node2}, traversed {traversed}\")\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\n #remove dummies\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\n #remove dummies\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\n logger.debug(f\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\")\n logger.debug(f\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\")\n if not nbrs1 or not nbrs2:\n if compare_two_nodes(G, node1, node2, ports_weight):\n match_pair[node1] = node2\n logger.debug(f\"no new neihbours, returning recursion {match_pair}\")\n return\n elif len(nbrs1)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n logger.debug(f\"skipping high fanout nets due to large computation, {node1} {nbrs1}\")\n traversed.append(node1)\n return\n elif len(nbrs2)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n traversed.append(node2)\n logger.debug(f\"skipping high fanout nets due to large computation, {node2} {nbrs2}\")\n return\n\n if node1 == node2:\n if node1 in match_pair.keys() or node1 in match_pair.values():\n logger.debug(\"avoid existing pair wise symmetry\")\n return\n logger.debug(f\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\")\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\n ## TBD: filter based on primitive constraints\n ## Right now will try to figure out S/D paths\n if len(SD_nbrs) ==0:\n logger.debug(f\"No SD paths found to traverse\")\n match_pair[node1]=node1\n elif len(SD_nbrs) ==1:\n logger.debug(f\"traversing single S/D path {SD_nbrs}\")\n match_pair[node1]=node1\n traversed.append(node1)\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\n else:\n logger.debug(f\" multiple nodes diverging {SD_nbrs}\")\n logger.debug(f\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\")\n match_pair[node1]=node1\n traversed.append(node1)\n new_sp=sorted(set(SD_nbrs)-set(traversed))\n all_match_pairs_local={}\n for nbr1,nbr2 in combinations(new_sp, 2):\n logger.debug(f\"recursive pair call from single branch {nbr1} {nbr2}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n if new_pair:\n #new_pair[nbr1]=nbr2\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\n if len(all_match_pairs_local)==1:\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\n logger.debug(f\"found inline pair: {pprint.pformat(match_pair, indent=4)}\")\n else:\n for nbr1 in new_sp:\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\n logger.debug(f\"recursive single branch call from single branch {nbr1} {nbr1}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif nbrs1 == nbrs2:\n logger.debug(f\"traversing converging branch\")\n match_pair[node1]=node2\n traversed+=[node1,node2]\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\n logger.debug(f\"all non traversed neighbours: {nbrs1}\")\n if len(nbrs1)==1:\n nbr1=nbr2=nbrs1[0]\n logger.debug(f\"keeping single converged branch inline {nbr1} {nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n else:\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\n logger.debug(f\"recursive call from converged branch {nbr1} {nbr2}\")\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif compare_two_nodes(G,node1,node2,ports_weight):\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\n match_pair[node1]=node2\n traversed+=[node1,node2]\n logger.debug(f\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\")\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\n if len(nbrs1)==0 or len(nbrs2)==0:\n logger.debug(f\"no new SD neihbours, returning recursion {match_pair}\")\n elif len(nbrs1) ==1 and len(nbrs2)==1:\n logger.debug(f\"traversing binary branch\")\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\n elif unique_match:\n logger.debug(f'traversing unique matches {unique_match}')\n match_pair[node1]=node2\n traversed+=[node1,node2]\n for nbr1,nbr2 in unique_match.items():\n logger.debug(f\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\n logger.debug(f\"setting new start points {node1} {node2}\")\n match_pair[node1]=node2\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n else:\n match_pair = {}\n logger.debug(f\"end all traversal from binary branch {node1} {node2}\")\n\n else:\n match_pair = {}\n logger.debug(f\"end of recursion branch, matches {match_pair}\")","def enumerate_links_around_node(self, node):\n\n l0 = self.node_link[node]\n l = l0\n edges = []\n traversing = True\n while traversing:\n edges.append(l)\n v = l[0]\n if v == node:\n l = self.pred_right[l]\n else:\n l = self.pred_left[l]\n if l0 == l:\n traversing = False\n if l0[1] == l[0] and l0[0] == l[1]:\n traversing = False\n #print v, l\n #raw_input('here')\n return edges","def directed_dfs(digraph, start, end, max_total_dist, max_dist_outdoors):\n\n\n path = [[],0 , 0]\n best_path = get_best_path(digraph, start, end, path, max_dist_outdoors, max_total_dist, best_path = None)\n\n if best_path[0] is None:\n raise ValueError('No work')\n else :\n return best_path[0]","def conversion(data_path, nodes, simtime, resolution=1):\r\n\r\n receivers = set() # i.e. neurons; senders can be external inputs\r\n edges_set = set()\r\n\r\n # Ask number of neurons per node\r\n nodes_dict = dict()\r\n if input(\"Every node has same number of neurons? (y/n)\") == \"y\":\r\n n = int(input(\"Number of neurons per node: \"))\r\n for node in range(nodes):\r\n nodes_dict[node] = n\r\n receivers.update([str(node) + \"-\" + str(neuron) for neuron in range(nodes_dict[node])])\r\n else:\r\n for node in range(nodes):\r\n nodes_dict[node] = int(input(\"Number of neurons in node %s: \" % node))\r\n receivers.update([str(node) + \"-\" + str(neuron) for neuron in range(nodes_dict[node])])\r\n\r\n receivers = sorted(list(receivers))\r\n\r\n # Load a part of FNS data to gather information about edges\r\n df = pd.read_csv(data_path, header=None, usecols=[0, 1, 2, 3, 4, 5], chunksize=500000, nrows=2000000)\r\n for chunk in df:\r\n chunk.columns = [\"Burning Time\", \"Firing Node\", \"Firing Neuron\", \"Burning Node\", \"Burning Neuron\",\r\n \"External Source\"]\r\n print(chunk.index)\r\n for node in range(nodes):\r\n temp = chunk.loc[\r\n (chunk[\"Burning Node\"] == node) & (chunk[\"External Source\"] == False)] # Remove external inputs\r\n for i in range(len(temp)):\r\n print(\"Gathering edge information for node: %i/%i. Connection: %i/%i\" % (\r\n node + 1, nodes, i + 1, len(temp)), end=\"\\r\")\r\n sender = str(np.asarray(temp[\"Firing Node\"])[i]) + \"-\" + str(np.asarray(temp[\"Firing Neuron\"])[i])\r\n receiver = str(node) + \"-\" + str(np.asarray(temp[\"Burning Neuron\"])[i])\r\n edges_set.add((sender, receiver))\r\n print(\"Gathering edge information for node: %i/%i. Connection: %i/%i\" % (node + 1, nodes, i + 1, len(temp)))\r\n\r\n status_table = pd.DataFrame(np.zeros((len(receivers), len(range((simtime - 1) * resolution)))),\r\n columns=list(range((simtime - 1) * resolution)), index=receivers)\r\n\r\n df = pd.read_csv(data_path, header=None, usecols=[0, 1, 2, 3, 4, 5], chunksize=1000000)\r\n for chunk in df:\r\n chunk.columns = [\"Burning Time\", \"Firing Node\", \"Firing Neuron\", \"Burning Node\", \"Burning Neuron\",\r\n \"External Source\"]\r\n print(chunk.index)\r\n\r\n # Loop over times instead of receivers: slightly better efficiency for large datasets\r\n times_raw = sorted(set(chunk[\"Burning Time\"]))\r\n status_table_temp = pd.DataFrame(columns=receivers)\r\n status_table_aux = pd.DataFrame(np.zeros((len(receivers), len(range((simtime - 1) * resolution)))),\r\n columns=list(range((simtime - 1) * resolution)), index=receivers)\r\n\r\n times = list(np.arange(0, int(max(times_raw) + 1), 1 / resolution))\r\n min_t = int(np.trunc(min(chunk[\"Burning Time\"])))\r\n max_t = int(np.trunc(max(chunk[\"Burning Time\"])))\r\n\r\n for t in times[min_t:max_t]:\r\n print(\"Gathering nodes' activity dynamics - t: %i/%i\" % (t + 1, max_t), end=\"\\r\")\r\n temp = chunk.loc[np.trunc(chunk[\"Burning Time\"]) == t, (\"Burning Node\", \"Burning Neuron\")]\r\n # Count burning events for each neuron at time t\r\n count = Counter([str(node) + \"-\" + str(neuron) for node, neuron in np.asarray(temp)])\r\n # Every time step we add a Counter dict to fill status table\r\n status_table_temp = status_table_temp.append(count, ignore_index=True)\r\n print(\"Gathering nodes' activity dynamics - t: %i/%i\" % (t + 1, max_t))\r\n\r\n # status_table_temp contains just a limited space of time each chunk\r\n status_table_temp = status_table_temp.transpose()\r\n status_table_temp.columns = list(\r\n np.arange(start=int(np.trunc(min(chunk[\"Burning Time\"]))), stop=int(np.trunc(max(chunk[\"Burning Time\"])))))\r\n status_table_temp = status_table_temp.fillna(0)\r\n\r\n # status_table_aux contains all time steps with temp table values and 0s for the rest each chunk\r\n status_table_aux = status_table_aux.add(status_table_temp)\r\n status_table_aux = status_table_aux.fillna(0)\r\n\r\n # status_table merges all chunks' data\r\n status_table = status_table.add(status_table_aux)\r\n status_table = status_table.fillna(0)\r\n\r\n timestamp = datetime.now()\r\n new_dir = \"gephiFiles\" + timestamp.strftime(\"d%d_%m_%Y-t%H_%M_%S\")\r\n os.mkdir(new_dir)\r\n\r\n # Generate gephi compliant files\r\n t = \"<\" + str(times) + \">\"\r\n gephi_nodes = pd.DataFrame(columns=[\"id\", \"label\", \"timeset\", \"events\", \"node\"])\r\n for idx, node in enumerate(receivers):\r\n print(\"Writing nodes' file for Gephi: %i/%i\" % (idx, len(receivers)), end=\"\\r\")\r\n events_row = [[float(i), int(events)] for i, events in enumerate(status_table.loc[node])]\r\n events_row = str(events_row).replace(\"[[\", \"<[\").replace(\"]]\", \"]>\").replace(\"],\", \"];\")\r\n new_row = pd.Series([node, node, t, events_row, node.split(\"-\")[0]], index=gephi_nodes.columns)\r\n gephi_nodes = gephi_nodes.append(new_row, ignore_index=True)\r\n print(\"Writing nodes' file for Gephi: %i/%i\" % (idx, len(receivers)))\r\n gephi_nodes.to_csv(new_dir + \"/gephi_nodes.csv\", index=False)\r\n\r\n print(\"Compute gephi files with %i edges will last %0.2fm approx.\" % (len(edges_set), len(edges_set) / 12000))\r\n if input(\"Do you want to proceed? (y/n) \") == \"n\":\r\n exit()\r\n gephi_edges = pd.DataFrame(columns=[\"Source\", \"Target\", \"type\", \"id\", \"weight\"])\r\n for idx, edge in enumerate(edges_set):\r\n print(\"Writing edges' file for Gephi: %i/%i\" % (idx, len(edges_set)), end=\"\\r\")\r\n edge_row = pd.Series([edge[0], edge[1], \"Directed\", idx, 1], index=gephi_edges.columns)\r\n gephi_edges = gephi_edges.append(edge_row, ignore_index=True)\r\n print(\"Writing edges' file for Gephi: %i/%i\" % (idx, len(edges_set)))\r\n gephi_edges.to_csv(new_dir + \"/gephi_edges.csv\", index=False)\r\n\r\n return None","def ssf(n, N_max = 6, E_max = 4, time_total = 100 ):\n\n G = nx.DiGraph()\n G.add_edge( 0, 1, time_stamp = 1)\n\n # List of existing nodes, with nodes repeated once for each adjacent edge\n repeated_nodes = [0, 1]\n\n # compute discrete bins for nodes \n DistNodes = _get_distribution( N_max, 0 )\n # compute discrete bins for edges\n DistLinks = _get_distribution( E_max, 1 )\n \n # Start adding the other n - 2 nodes.\n N_current = time_current = 2\n while N_current < n and time_current < time_total + 1:\n # preferential attachment\n N_current = _preferential_attachment( DistNodes, DistLinks, N_current,\n time_total, time_current, n, repeated_nodes, G )\n time_current += 1\n \n# print(time_current, N_current)\n return G","def calc_overall_link_utilisation(self, demands: Demand,\n routing: Routing) -> np.ndarray:\n flows = [(i, j) for i in range(self.num_nodes)\n for j in range(self.num_nodes)\n if i != j]\n\n link_utilisation = np.zeros(self.num_edges)\n\n for i, flow in enumerate(flows):\n flow_link_utilisation = self.calc_per_flow_link_utilisation(flow,\n demands[\n i],\n routing[\n i])\n link_utilisation += flow_link_utilisation\n\n return link_utilisation","def hmn1(a, p, s, m0):\n n = 2*m0**s\n links = np.zeros((2*int(a/m0*n*sum([1/2**x for x in range(1, s+1)])), 2), dtype=np.int32)\n\n links_i = 0\n for si in range(1, s+1):\n # 2 Blocks at the same level get linked with\n # a shrinking probability with rising level.\n m0_si = m0**si\n for n in range(0, n+1-2*m0_si, 2*m0_si):\n # Connection ensures that at the end of each\n # linking process, at least one link between\n # blocks at the same level exists.\n m0_si_n = m0_si + n\n connection = 0\n while connection == 0:\n for link1 in range(n, m0_si_n):\n for link2 in range(m0_si_n, 2*m0_si+n): \n if np.random.rand() < a*p**si:\n links[links_i] = [link1, link2]\n links_i += 1\n connection = 1\n \n # Creates the links in the blocks and removes empty\n # placeholders in links.\n blocks = np.arange(n).reshape((int(n/m0), m0))\n links = np.trim_zeros(links.ravel(), 'b').reshape((links_i, 2))\n\n return np.concatenate((blocks, links))","def get_flows(self, x):\n if self.pa_frames == 2:\n flows_backward, flows_forward = self.get_flow_2frames(x)\n elif self.pa_frames == 4:\n flows_backward_2frames, flows_forward_2frames = self.get_flow_2frames(x)\n flows_backward_4frames, flows_forward_4frames = self.get_flow_4frames(flows_forward_2frames, flows_backward_2frames)\n flows_backward = flows_backward_2frames + flows_backward_4frames\n flows_forward = flows_forward_2frames + flows_forward_4frames\n elif self.pa_frames == 6:\n flows_backward_2frames, flows_forward_2frames = self.get_flow_2frames(x)\n flows_backward_4frames, flows_forward_4frames = self.get_flow_4frames(flows_forward_2frames, flows_backward_2frames)\n flows_backward_6frames, flows_forward_6frames = self.get_flow_6frames(flows_forward_2frames, flows_backward_2frames, flows_forward_4frames, flows_backward_4frames)\n flows_backward = flows_backward_2frames + flows_backward_4frames + flows_backward_6frames\n flows_forward = flows_forward_2frames + flows_forward_4frames + flows_forward_6frames\n return flows_backward, flows_forward","def BellmanFord(t):\n\n\td = [float('inf') for i in nodes]\t# Shortest distance to t\n\tn = [-1 for i in nodes]\t\t\t# Next hop toward t\n\td[t] = 0\n\tfor i in range(len(nodes)-1):\n\t\tfor j,(u,v) in enumerate(links):\n\t\t\tif d[u] > d[v] + length[j]:\n\t\t\t\td[u] = d[v] + length[j] \n\t\t\t\tn[u] = v\n\treturn n,d","def get_bipartition(g):\n # Write your code here.\n colorArr = [-1] * (len(g.nodes()) + 1)\n for node in g.nodes():\n start = g.neighbors(node)\n if len(start)>0:\n src = start.pop()\n break\n colorArr[src] = 1\n queue = []\n queue.append(src)\n while (queue):\n u = queue.pop()\n for v in g.nodes():\n if g.has_edge(u, v) and colorArr[v] == -1:\n colorArr[v] = 1 - colorArr[u]\n queue.append(v)\n elif g.has_edge(u, v) and colorArr[u] == colorArr[v]:\n return None\n\n red = set()\n for i in range(1, len(colorArr)):\n if colorArr[i] == 1:\n red.add(i)\n return list(red)\n\n\n\n # Hint! If you'd like to test out these commands without\n # writing a full-fledged program, you might want to familiarise\n # yourself with the Python interactive shell or IPython (available\n # on at least some Aalto IT computers)\n\n # Create a simple line graph g: \"(1)->(2)->(3)\"\n # (The creation parameter is a dict of {node: list_of_neighbors},\n # but this is not something you will be needing in your code.)\n # >>> from networkx import Graph \n # >>> g = Graph({1: [2], 2: [3]})\n # >>> g.number_of_nodes()\n # 3\n\n # Example. Iterate over the nodes and mark them as visited\n # >>> visited = set()\n # >>> for node in g.nodes_iter(): # There is also g.nodes(), which returns a list\n # ... # do some work here\n # ... visited.add(node)\n \n # Example. Given a Node v, get all nodes s.t. there is an edge between\n # v and that node\n # >>> g.neighbors(1)\n # [2]\n\n # Example. Get the edges of the graph:\n # >>> e.edges() # as with nodes, there is also g.edges_iter()\n # [(1, 2), (2, 3)]\n\n # For more information, consult the NetworkX documentation:\n # https://networkx.github.io/documentation/networkx-1.10/tutorial/tutorial.html","def separate_simulations(ns, ps, rs, savename, verbose=True):\n #TODO: find bug that occasionally does not find the shortest path\n if verbose:\n\n for n, p, r in zip(ns, ps, rs):\n \n print('n-{}, p-{}, r-{}'.format(n, p, r))\n \n rand_points = np.random.uniform(size=(2, n-2))\n edge_points = np.array([[0.0, 1.0],[0.0, 1.0]])\n points = np.concatenate((rand_points, edge_points), axis=1)\n \n print('Generated points.', end = '')\n \n connections = get_connections(points, pval=p, radius=r)\n\n print('Got connections.')\n \n print('Getting paths.', end = '...')\n \n print('Longest.', end = '...')\n long_pathBool, long_lengthBool = longest_path(connections.astype(bool))\n long_path, long_length = longest_path(connections)\n\n print('Shortest.', end = '...')\n short_pathBool, short_lengthBool = shortest_path(connections.astype(bool))\n short_path, short_length = shortest_path(connections)\n\n short_pathBoolpoints, long_pathBoolpoints, short_pathpoints, long_pathpoints = [[list(points[:, u]) for u in indexes] for indexes in [short_pathBool, long_pathBool, short_path, long_path]]\n\n print('Saving file -> ' + savename)\n file1 = open(savename,\"a\") \n\n file1.writelines('{} - {} - {} - {} - {} - {} - {} - {} - {} - {} - {}\\n'.format(p, r, n, short_lengthBool, long_lengthBool, short_length, long_length, short_pathBoolpoints, long_pathBoolpoints, short_pathpoints, long_pathpoints))\n file1.close()\n \n else:\n\n for n, p, s in zip(ns, ps, rs):\n\n rand_points = np.random.uniform(size=(2, n-2))\n edge_points = np.array([[0.0, 1.0],[0.0, 1.0]])\n points = np.concatenate((rand_points, edge_points), axis=1)\n\n connections = get_connections(points, pval=p, radius=r)\n\n long_pathBool, long_lengthBool = longest_path(connections.astype(bool))\n long_path, long_length = longest_path(connections)\n\n short_pathBool, short_lengthBool = shortest_path(connections.astype(bool))\n short_path, short_length = shortest_path(connections)\n\n short_pathBoolpoints, long_pathBoolpoints, short_pathpoints, long_pathpoints = [[list(points[:, u]) for u in indexes] for indexes in [short_pathBool, long_pathBool, short_path, long_path]]\n\n file1 = open(savename,\"a\") \n\n file1.writelines('{} - {} - {} - {} - {} - {} - {} - {} - {} - {} - {}\\n'.format(p, r, n, short_lengthBool, long_lengthBool, short_length, long_length, short_pathBoolpoints, long_pathBoolpoints, short_pathpoints, long_pathpoints))\n file1.close()\n \n return True","def get_path(self, sim, app_name, message, topology_src, alloc_DES, alloc_module, traffic, from_des):\n node_src = topology_src\n DES_dst = alloc_module[app_name][message.dst] # returns an array with all DES process serving\n\n if message.dst not in self.rr.keys():\n self.rr[message.dst] = 0\n\n # print (\"GET PATH\")\n # print (\"\\tNode _ src (id_topology): %i\" % node_src)\n # print (\"\\tRequest service: %s \" % (message.dst))\n # print (\"\\tProcess serving that service: %s (pos ID: %i)\" % (DES_dst, self.rr[message.dst]))\n\n bestPath = []\n bestDES = []\n\n for ix, des in enumerate(DES_dst):\n if message.name == \"RawVideo\" or message.name == \"IdentifyObject\":\n if self.rr[message.dst] == ix:\n dst_node = alloc_DES[des]\n\n path = list(nx.shortest_path(sim.topology.G, source=node_src, target=dst_node, weight='BW'))\n\n bestPath = [path]\n bestDES = [des]\n\n self.rr[message.dst] = (self.rr[message.dst] + 1) % len(DES_dst)\n break\n else: # message.name == \"M.B\"\n\n dst_node = alloc_DES[des]\n\n path = list(nx.shortest_path(sim.topology.G, source=node_src, target=dst_node, weight='BW'))\n if message.broadcasting:\n bestPath.append(path)\n bestDES.append(des)\n else:\n bestPath = [path]\n bestDES = [des]\n\n return bestPath, bestDES","def find_all_feedback_from_FVS(lt_links, ls_FVS=None):\n if not ls_FVS:\n set_nodes = set([])\n for t_link in lt_links:\n set_nodes.add(t_link[0])\n set_nodes.add(t_link[1])\n ls_FVS = FVS_analysis.FVS_finding(list(set_nodes), lt_links)[0]\n #if FVS nodes are already gained, pass this step\n \n llt_feedbacks = []\n dic_ts_FVSnodepair_llt_downstreams = {}#{(FVS node1, FVS node2):list of lt_downstream which starts at FVS node1 and ends at FVS node2}\n for s_FVSnode in ls_FVS:\n llt_downstreams = find_all_downstream_from_seed(lt_links, s_FVSnode, ls_FVS)\n for lt_downstream in llt_downstreams:\n ts_FVSpair = (s_FVSnode, lt_downstream[-1][-1])\n dic_ts_FVSnodepair_llt_downstreams.setdefault(ts_FVSpair,[]).append(lt_downstream)\n \n lts_cyclesofFVS = get_all_cycles(ls_FVS)\n for ts_cycleofFVS in lts_cyclesofFVS:\n if len(ts_cycleofFVS) == 1:\n llt_feedbacks.extend(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[0],ts_cycleofFVS[0])])\n else:\n b_stopflag = False\n lllt_feedbackfragment = []\n for i in range(len(ts_cycleofFVS)-1):\n lllt_feedbackfragment.append(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[i], ts_cycleofFVS[i+1])])\n if not dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[i], ts_cycleofFVS[i+1])]:\n b_stopflag = True\n break\n lllt_feedbackfragment.append(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[-1],ts_cycleofFVS[0])])\n if not dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[-1],ts_cycleofFVS[0])]:\n b_stopflag = True\n if b_stopflag:\n continue#if there is no feedback passing by all FVS nodes of that cycle, pass to next cycle\n \n llt_feedbacks_specific_cycle = lllt_feedbackfragment.pop(0)\n while lllt_feedbackfragment:\n llt_fragments_next = lllt_feedbackfragment.pop(0)\n llt_feedbacks_updated = []\n for lt_fragment in llt_feedbacks_specific_cycle:\n for lt_fragment_next in llt_fragments_next:\n ls_route = [t_link[1] for t_link in lt_fragment[:-1]]\n ls_route_next = [t_link[1] for t_link in lt_fragment_next[:-1]]\n if not set(ls_route).intersection(set(ls_route_next)):\n llt_feedbacks_updated.append(lt_fragment+lt_fragment_next)\n llt_feedbacks_specific_cycle = llt_feedbacks_updated\n llt_feedbacks.extend(llt_feedbacks_specific_cycle)\n\n return llt_feedbacks","def test_get_dependencies_subgraph_by_dfs(\n self, source_node, expected_nodes_in, expected_nodes_out\n ):\n graph = nx.DiGraph()\n graph.add_node(\"pack1\")\n graph.add_node(\"pack2\")\n graph.add_node(\"pack3\")\n graph.add_node(\"pack4\")\n graph.add_edge(\"pack1\", \"pack2\")\n graph.add_edge(\"pack2\", \"pack3\")\n dfs_graph = PackDependencies.get_dependencies_subgraph_by_dfs(\n graph, source_node\n )\n for i in expected_nodes_in:\n assert i in dfs_graph.nodes()\n for i in expected_nodes_out:\n assert i not in dfs_graph.nodes()","def find_sharpest_fork_general(Nodes):\n pair_list = []\n Dis = np.array([])\n for n in Nodes:\n if n.parent is not None:\n if n.parent.parent is not None:\n a = n.parent.children\n if(isinstance(a, list)):\n if(len(a)==2):\n n1 = a[0]\n n2 = a[1]\n pair_list.append([n1 , n2])\n dis = LA.norm(a[0].xyz - a[1].xyz,2)\n Dis = np.append(Dis,dis)\n if(len(Dis)!= 0):\n (b,) = np.where(Dis == Dis.min())\n sharpest_pair = pair_list[b[0]]\n distance = Dis.min()\n else:\n sharpest_pair = [0,0]\n distance = 0.\n return sharpest_pair, distance","def get_bfs(self, s):\n # create a queue for BFS\n queue = []\n # mark all the vertices as not visited\n visited = [False] * (len(self.graph))\n # mark the start node as visited and enqueue it\n visited[s] = True\n queue.append(s)\n results = []\n\n while queue:\n # dequeue a vertex from queue and append to results.\n p = queue.pop(0)\n results.append(p)\n # get all adjacent vertices of the dequeued vertex s,\n # and for any unvisited adjacent, mark it visited and enqueue it.\n for v in self.graph[p]:\n if visited[v] is False:\n visited[v] = True\n queue.append(v)\n\n return results","def sinks(self):\n if self.rank < self.midpoint:\n partner = self.midpoint + (self.rank - self.left)\n if partner == self.right:\n partner -= 1\n else:\n partner = self.left + (self.rank - self.midpoint)\n if partner == self.midpoint:\n partner -= 1\n\n return {partner}","def bfs_traversal(graph, s, goals=[]):\n visited = []\n boundary = deque([s])\n while len(boundary) > 0:\n v = boundary.popleft()\n visited += [v]\n if v in goals:\n return visited\n for w in neighbours(v, graph):\n if w not in visited and w not in boundary:\n boundary.append(w)\n return visited\n\n \"\"\"\n visited = []\n boundary = [s]\n while len(boundary) > 0:\n v = boundary.pop(0)\n visited += [v]\n for w in neighbours(v, graph):\n if w not in goals:\n if w not in visited and w not in boundary:\n boundary.append(w)\n else:\n if w not in visited and w not in boundary:\n boundary.append(w)\n v = boundary.pop(0)\n visited += [v]\n break\n return visited\n \"\"\"","def refugia_adj_5_simsplit(params, ns):\n #20 parameters \n nu1a, nu2a, nu3a, nu1b, nu2b, nu3b, m2_12, m2_13, m2_21, m2_23, m2_31, m2_32, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T2, T3 = params\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\n fs = moments.Spectrum(sts)\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2]) \n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\n ## Population function and migration matrix for T2\n nu_T2 = [nu1a, nu2a, nu3a]\n mig2 = numpy.array([[0, m2_12, m2_13],[m2_21, 0, m2_23], [m2_31, m2_32, 0]]) \n fs.integrate(nu_T2, T2, m=mig2)\n ## Population function and migration matrix for T3\n nu_T3 = [nu1b, nu2b, nu3b]\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \n fs.integrate(nu_T3, T3, m=mig3) \n return fs","def dfs_edges_generator(graph, source, reverse=...):\n ...","def bfs_edges_generator(graph, source, reverse=...):\n ...","def bfs_path(graph, s, goals=[]):\n visited = []\n parents = [None]*len(graph)\n boundary = [s]\n while len(boundary) > 0:\n v = boundary.pop(0)\n visited += [v]\n for w in neighbours(v, graph):\n if w not in visited and w not in boundary:\n boundary.append(w)\n parents[w] = v\n #w's parent\n # put w's parent in the partent list\n return get_path(parents, goals[0], goals[1])","def compute_path_hopping_flow_allocations(target_graph, K=3):\n flow_allocation_seed_number = 0xCAFE_BABE\n np.random.seed(flow_allocation_seed_number)\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n link_utilization = {(u, v): 0.0 for u, v in target_graph.edges}\n node_capacity = {u: 0.0 for u in target_graph.nodes}\n flows = []\n while True:\n source_node, destination_node = flow_selection_fn(target_graph.nodes, 2, replace=False)\n print(source_node, destination_node)\n\n shortest_paths = sorted(nx.all_simple_paths(target_graph, source_node, destination_node,\n cutoff=3),\n key=lambda p: len(p))\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\n\n # flow_tx_rate = np.random.uniform() * 10\n flow_tx_rate = 1.0\n # if node_capacity[source_node] + flow_tx_rate > LINK_CAPACITY:\n # break\n node_capacity[source_node] += flow_tx_rate\n capacity_was_exceeded = False \n for path in [nx.utils.pairwise(p_i) for p_i in k_shortest_paths]:\n for u, v in [sorted(h_i) for h_i in path]:\n flow_rate_per_subpath = flow_tx_rate / K\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\n capacity_was_exceeded = True\n break\n link_utilization[u, v] += flow_rate_per_subpath\n if capacity_was_exceeded:\n break\n\n if capacity_was_exceeded:\n break\n\n the_flow = Flow( source_node = source_node\n , destination_node = destination_node\n , flow_tx_rate = flow_tx_rate\n , paths = k_shortest_paths\n , splitting_ratio = [1.0/K]*K\n )\n flows.append(the_flow)\n return flows, link_utilization","def _compute_longest_path_cut(self, src_uid, dst_uid):\n # NOTE: at the time being the reason why it was chosen to include edges\n # that belong to any path to the returned list, is unclear to me.\n to_visit_uids = [dst_uid]\n node_costs = {}\n node_succs = {}\n subgraph_edge_uids = []\n subgraph_node_uids = [src_uid]\n dsp = 0\n\n if (src_uid == dst_uid): # NOTE: deals with single-block graphs\n node = self._nodes[src_uid]\n return node.get_cost(), [src_uid], [], []\n\n # NOTE: the generated block graph might contain dead ends, thus\n # visited_uids must be pre-computed\n visited_uids = copy.deepcopy(self._nodes.keys())\n lvisited_uids = []\n while len(to_visit_uids) > 0:\n cur_uid = to_visit_uids[0]\n cur_node = self._nodes[cur_uid]\n\n if cur_uid in visited_uids:\n visited_uids.remove(cur_uid)\n\n for pred_uid in cur_node.get_predecessors():\n if pred_uid not in to_visit_uids and pred_uid not in lvisited_uids:\n to_visit_uids.append(pred_uid)\n\n to_visit_uids = to_visit_uids[1:]\n lvisited_uids.append(cur_uid)\n\n to_visit_uids = [dst_uid]\n\n # reverse graph exploration\n while 0 < len(to_visit_uids):\n assert(dsp < len(to_visit_uids))\t# dead ends or loops\n\n cur_uid = to_visit_uids[dsp]\n cur_node = self._nodes[cur_uid]\n\n assert(cur_uid != src_uid)\n assert(cur_uid not in visited_uids)\t# loop!\n\n # skip node for which there is still some unexplored successor\n skip_uid = False\n for succ_uid in cur_node.get_successors():\n if not succ_uid in visited_uids:\n skip_uid = True\n\n if skip_uid:\n dsp += 1\n continue\n else:\n dsp = 0\n\n if cur_uid == dst_uid:\n node_costs[cur_uid] = cur_node.get_cost()\n\n for pred_uid in cur_node.get_predecessors():\n pred_node = self._nodes[pred_uid]\n # get edge pred_uid ---> cur_uid\n edge_uid = Edge.get_edge_uid(pred_uid, cur_uid)\n edge = self._edges[edge_uid]\n edge_cost = edge.get_cost()\n if edge_uid not in subgraph_edge_uids:\n subgraph_edge_uids.append(edge_uid)\n\n # update node distance\n pred_node_cost = node_costs[cur_uid] + edge_cost + pred_node.get_cost()\n if pred_uid not in node_costs or pred_node_cost > node_costs[pred_uid]:\n node_costs[pred_uid] = pred_node_cost\n node_succs[pred_uid] = cur_uid\n\n # update to_visit_uids, a node cannot be visited more than once\n if (pred_uid != src_uid) and (pred_uid not in visited_uids) \\\n and (pred_uid not in to_visit_uids):\n to_visit_uids.append(pred_uid)\n\n to_visit_uids.remove(cur_uid)\n visited_uids.append(cur_uid)\n subgraph_node_uids.append(cur_uid)\n\n # construct path from src_node to dst_node\n cur_uid = src_uid\n maxpath_node_uids = [cur_uid]\n while cur_uid != dst_uid:\n cur_uid = node_succs[cur_uid]\n cur_node = self._nodes[cur_uid]\n if cur_uid not in maxpath_node_uids:\n maxpath_node_uids.append(cur_uid)\n else:\n raise Exception(\"invalid input source code graph: loop detected\")\n\n max_cost = node_costs[src_uid]\n return max_cost, maxpath_node_uids, subgraph_node_uids, subgraph_edge_uids","def _compute_paths_among(self, src_uid, dst_uid):\n to_visit_uids = [dst_uid]\n paths = {}\n idx = 0\n dsp = 0\n\n if (src_uid == dst_uid): # NOTE: deals with single-block graphs\n return [src_uid]\n\n # NOTE: the generated block graph might contain dead ends, thus\n # visited_uids must be pre-computed\n visited_uids = copy.deepcopy(self._nodes.keys())\n lvisited_uids = []\n while len(to_visit_uids) > 0:\n cur_uid = to_visit_uids[0]\n cur_node = self._nodes[cur_uid]\n\n if cur_uid in visited_uids:\n visited_uids.remove(cur_uid)\n\n for pred_uid in cur_node.get_predecessors():\n if pred_uid not in to_visit_uids and pred_uid not in lvisited_uids:\n to_visit_uids.append(pred_uid)\n\n to_visit_uids = to_visit_uids[1:]\n lvisited_uids.append(cur_uid)\n\n to_visit_uids = [dst_uid]\n\n while idx < len(to_visit_uids):\n assert(idx + dsp < len(to_visit_uids))\n\n cur_uid = to_visit_uids[idx + dsp]\n cur_node = self._nodes[cur_uid]\n\n assert(cur_uid != src_uid)\n assert(cur_uid not in visited_uids)\n\n # skip node for which there is still some unexplored successor\n skip_uid = False\n for succ_uid in cur_node.get_successors():\n if succ_uid not in visited_uids:\n skip_uid = True\n\n if skip_uid:\n dsp += 1\n continue\n else:\n dsp = 0\n\n if cur_uid == dst_uid:\n paths[cur_uid] = 1\n\n for pred_uid in cur_node.get_predecessors():\n if pred_uid not in paths:\n paths[pred_uid] = paths[cur_uid]\n else:\n paths[pred_uid] += paths[cur_uid]\n\n # a node cannot be visited more than once\n if pred_uid != src_uid and pred_uid not in visited_uids \\\n and pred_uid not in to_visit_uids:\n to_visit_uids.append(pred_uid)\n\n to_visit_uids.remove(cur_uid)\n visited_uids.append(cur_uid)\n\n return paths[src_uid]","def get_skims(G, transfer_penalty=300, delta=0.2):\n # shortest path\n sp = nx.shortest_path(G, weight='total_travel_time')\n # create a dictionary for stop travel impedance values\n # The travel impedance is also decomposed\n # GTC: total generalized travel cost\n # IVT: in-vehicle travel time\n # NONIVT: the remaining part related to transfer and waiting times\n ti = {}\n fields = ['GTC', \"IVT\", \"WT\", \"TRANSFER\", \"NONIVT\"]\n for key in sp.keys():\n ti[key] = {}\n for field in fields:\n ti[key][field] = dict()\n for source in sp.keys():\n for target in sp[source].keys():\n cur_sp = sp[source][target]\n for field in fields:\n ti[source][field][target] = 0\n if not len(cur_sp) == 1:\n # if not the node itself\n for k in range(len(cur_sp) - 1):\n i = cur_sp[k]\n j = cur_sp[k + 1]\n ti[source]['IVT'][target] += G[i][j]['ivt']\n ti[source]['WT'][target] += G[i][j]['wt']\n ti[source]['NONIVT'][target] += G[i][j]['wt']\n ti[source]['NONIVT'][target] += (len(cur_sp) - 2) * transfer_penalty\n ti[source]['TRANSFER'][target] = (len(cur_sp) - 2) * transfer_penalty\n ti[source]['GTC'][target] = ti[source]['IVT'][target] + ti[source]['NONIVT'][target]\n\n skims = DotMap()\n for field in fields:\n skims[field] = pd.DataFrame([ti[i][field] for i in sp.keys()], index=sp.keys())\n\n x_list = list(nx.get_node_attributes(G, 'x').values())\n y_list = list(nx.get_node_attributes(G, 'y').values())\n df = pd.DataFrame({'node_id': list(sp.keys()), 'x': x_list, 'y': y_list})\n df = df.set_index('node_id')\n\n skims['pos'] = df\n return skims","def get_routing_solution(self):\n G = self.base_digraph\n s1 = self.sources[0]\n s2 = self.sources[1]\n t1 = self.destinations[0]\n t2 = self.destinations[1]\n\n try:\n m = Model('routing')\n m.setParam('OutputFlag', False)\n\n # variables,\n # We have one variable per edge per session\n # e is the dict of dict for the variables\n e = {}\n r = {}\n for i in [1,2]:\n e[i] = {}\n r[i] = m.addVar()\n for u,v in G.edges():\n e[i][u,v] = m.addVar(lb=0)\n\n m.update()\n\n obj = quicksum(r.values())\n m.setObjective(obj, GRB.MAXIMIZE)\n\n # constraints\n # 1. conservations of flow at all intermediate nodes\n # 2. capacity constraints for each edge\n\n for u,v in G.edges():\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\n\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\n\n for n in G.nodes():\n if n not in [s1, s2, t1, t2]:\n for i in [1, 2]:\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\n m.addConstr(inflow == outflow)\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n for u, v in G.edges():\n G[u][v]['Routing'] = {}\n G[u][v]['Routing'][1] = e[1][u,v].x\n G[u][v]['Routing'][2] = e[2][u,v].x\n return (m.objVal, r[1].x, r[2].x)\n else:\n # something went wrong...err...\n print \"Something was wrong, no optimal solution obtained\"\n return None, None, None\n\n except GurobiError:\n Print ('Error Report from Gurobi')","def dfs_path(graph, s, goals=[]):\n visited = []\n parents = [None]*(len(graph))\n boundary = [s]\n while len(boundary) > 0:\n v = boundary.pop()\n visited += [v]\n for w in neighbours(v, graph):\n if w not in visited and w not in boundary:\n boundary.append(w)\n parents[w] = v\n return get_path(parents, goals[0], goals[1])","def caculate_network_statistics(self):\n divide_factor_sum = 0 \n for key in self.stars.keys():\n star = self.stars[key]\n if star.nb_num == 0 :\n self.standalone_star_num += 1 \n\n divide_factor = star.nb_num + 2 * (star.spec_num - star.shared_spec_num )/self.ave_starlet_size\n divide_factor_sum += divide_factor\n divide_factor_int = round(divide_factor)\n self.star_divide_factor_dist[divide_factor_int] = self.star_divide_factor_dist.get(divide_factor_int,0) + 1\n if star.spec_num < star.shared_spec_num:\n print(\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\")\n print(\"with star \" + star.id + \" \" + str(star.spec_num) + \"is less than\" + str(star.shared_spec_num))\n if star.spec_num > star.shared_spec_num:\n self.star_lost_spec_num += star.spec_num - star.shared_spec_num\n self.ave_divide_factor_star = divide_factor_sum/self.stars_length\n\n divide_factor_sum = 0 \n for key in self.starlets.keys():\n starlet = self.starlets[key]\n if starlet.nb_num == 0 :\n self.standalone_starlet_num += 1 \n\n divide_factor = starlet.nb_num + 2 * (starlet.spec_num - starlet.shared_spec_num )/self.ave_star_size\n divide_factor_sum += divide_factor\n divide_factor_int = round(divide_factor)\n self.starlet_divide_factor_dist[divide_factor_int] = self.starlet_divide_factor_dist.get(divide_factor_int,0) + 1\n if starlet.spec_num < starlet.shared_spec_num:\n print(\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\")\n print(\"with star \" + starlet.id + \" \" + str(starlet.spec_num) + \"is less than\" + str(starlet.shared_spec_num))\n if starlet.spec_num > starlet.shared_spec_num:\n self.starlet_lost_spec_num += starlet.spec_num - starlet.shared_spec_num\n self.ave_divide_factor_starlet = divide_factor_sum/self.starlets_length","def Sidetrack2Path(tree, sidetracks, s, t):\n\tvisited = set()\t\t# visited nodes\n\tpath = []\t\t# set of edges\n\tsidenodes = set(links[e][0] for e in sidetracks)\t# nodes that needs to be sidetracked\n\tcurrent = s\n\twhile current != t:\n\t\t# Loop detection\n\t\tif current in visited:\n\t\t\treturn []\n\t\telse:\n\t\t\tvisited.add(current)\n\t\t# No loop is found yet, proceed one hop\n\t\tif current in sidenodes:\n\t\t\tedge = [e for e in sidetracks if links[e][0] == current]\n\t\t\tcurrent = links[edge[0]][1]\n\t\t\tpath.append(edge[0])\n\t\telse:\n\t\t\tedge = [i for i,e in enumerate(links) if e == (current,tree[current])]\n\t\t\tcurrent = links[edge[0]][1]\n\t\t\tpath.append(edge[0])\n\t# Destination reached. Return the path\n\treturn path","def test_tree_splay() -> None:\n t = generate_graph_resources(5)\n field(t, (\"dr_1\", \"ds_1\", \"f1\")).references.append(\n (FieldAddress(\"dr_2\", \"ds_2\", \"f1\"), \"to\")\n )\n field(t, (\"dr_1\", \"ds_1\", \"f1\")).references.append(\n (FieldAddress(\"dr_3\", \"ds_3\", \"f1\"), \"to\")\n )\n field(t, (\"dr_1\", \"ds_1\", \"f1\")).references.append(\n (FieldAddress(\"dr_4\", \"ds_4\", \"f1\"), \"to\")\n )\n field(t, (\"dr_1\", \"ds_1\", \"f1\")).references.append(\n (FieldAddress(\"dr_5\", \"ds_5\", \"f1\"), \"to\")\n )\n field(t, (\"dr_1\", \"ds_1\", \"f1\")).identity = \"email\"\n traversal = Traversal(DatasetGraph(*t), {\"email\": \"X\"})\n\n assert incoming_edges(traversal, CollectionAddress(\"dr_1\", \"ds_1\")) == {\n Edge(\n FieldAddress(\"__ROOT__\", \"__ROOT__\", \"email\"),\n FieldAddress(\"dr_1\", \"ds_1\", \"f1\"),\n )\n }\n assert outgoing_edges(traversal, CollectionAddress(\"dr_1\", \"ds_1\")) == {\n Edge(FieldAddress(\"dr_1\", \"ds_1\", \"f1\"), FieldAddress(\"dr_3\", \"ds_3\", \"f1\")),\n Edge(FieldAddress(\"dr_1\", \"ds_1\", \"f1\"), FieldAddress(\"dr_4\", \"ds_4\", \"f1\")),\n Edge(FieldAddress(\"dr_1\", \"ds_1\", \"f1\"), FieldAddress(\"dr_5\", \"ds_5\", \"f1\")),\n Edge(FieldAddress(\"dr_1\", \"ds_1\", \"f1\"), FieldAddress(\"dr_2\", \"ds_2\", \"f1\")),\n }\n\n assert outgoing_edges(traversal, CollectionAddress(\"dr_5\", \"ds_5\")) == set()\n assert incoming_edges(traversal, CollectionAddress(\"dr_2\", \"ds_2\")) == {\n Edge(FieldAddress(\"dr_1\", \"ds_1\", \"f1\"), FieldAddress(\"dr_2\", \"ds_2\", \"f1\"))\n }\n assert incoming_edges(traversal, CollectionAddress(\"dr_3\", \"ds_3\")) == {\n Edge(FieldAddress(\"dr_1\", \"ds_1\", \"f1\"), FieldAddress(\"dr_3\", \"ds_3\", \"f1\"))\n }\n assert incoming_edges(traversal, CollectionAddress(\"dr_4\", \"ds_4\")) == {\n Edge(FieldAddress(\"dr_1\", \"ds_1\", \"f1\"), FieldAddress(\"dr_4\", \"ds_4\", \"f1\"))\n }\n assert incoming_edges(traversal, CollectionAddress(\"dr_5\", \"ds_5\")) == {\n Edge(FieldAddress(\"dr_1\", \"ds_1\", \"f1\"), FieldAddress(\"dr_5\", \"ds_5\", \"f1\"))\n }\n traversal_map, terminators = traversal.traversal_map()\n assert traversal_map == {\n \"__ROOT__:__ROOT__\": {\"from\": {}, \"to\": {\"dr_1:ds_1\": {\"email -> f1\"}}},\n \"dr_1:ds_1\": {\n \"from\": {\"__ROOT__:__ROOT__\": {\"email -> f1\"}},\n \"to\": {\n \"dr_2:ds_2\": {\"f1 -> f1\"},\n \"dr_3:ds_3\": {\"f1 -> f1\"},\n \"dr_4:ds_4\": {\"f1 -> f1\"},\n \"dr_5:ds_5\": {\"f1 -> f1\"},\n },\n },\n \"dr_2:ds_2\": {\"from\": {\"dr_1:ds_1\": {\"f1 -> f1\"}}, \"to\": {}},\n \"dr_3:ds_3\": {\"from\": {\"dr_1:ds_1\": {\"f1 -> f1\"}}, \"to\": {}},\n \"dr_4:ds_4\": {\"from\": {\"dr_1:ds_1\": {\"f1 -> f1\"}}, \"to\": {}},\n \"dr_5:ds_5\": {\"from\": {\"dr_1:ds_1\": {\"f1 -> f1\"}}, \"to\": {}},\n }\n\n assert set(terminators) == {\n CollectionAddress(\"dr_2\", \"ds_2\"),\n CollectionAddress(\"dr_3\", \"ds_3\"),\n CollectionAddress(\"dr_4\", \"ds_4\"),\n CollectionAddress(\"dr_5\", \"ds_5\"),\n }","def get_weight_from_minflow(self):\n start_nodes = []\n end_nodes = []\n capacities = []\n unit_costs = []\n A = 0\n s_prime = self.sink() + 1\n t_prime = self.sink() + 2\n x = self.sink() + 3\n # for every edge in the graph, add edge to mincost flow instance with\n # infinite capacity and cost 1\n # also add backwards edge\n for arc in self.arc_info.keys():\n # forward edge\n start_nodes.append(self.arc_info[arc][\"start\"])\n end_nodes.append(self.arc_info[arc][\"destin\"])\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"start\"],\n self.arc_info[arc][\"destin\"]))\n # backward edge\n start_nodes.append(self.arc_info[arc][\"destin\"])\n end_nodes.append(self.arc_info[arc][\"start\"])\n capacities.append(int(self.arc_info[arc][\"weight\"])) # no negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"destin\"],\n self.arc_info[arc][\"start\"]))\n # add (x,s) and (t,x) edges with same cap, cost as above\n in_weight_x = 0\n for in_arc in self.in_arcs_lists[self.sink()]:\n in_weight_x += self.arc_info[in_arc][\"weight\"]\n out_weight_x = 0\n for out_arc in self.out_arcs_lists[self.source()]:\n out_weight_x += self.arc_info[out_arc][\"weight\"]\n # (x,s)\n start_nodes.append(x)\n end_nodes.append(self.source())\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.source()))\n # backward\n start_nodes.append(self.source())\n end_nodes.append(x)\n capacities.append(int(out_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.source(),\n x))\n # (t,x)\n start_nodes.append(self.sink())\n end_nodes.append(x)\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.sink(),\n x))\n # backward\n start_nodes.append(x)\n end_nodes.append(self.sink())\n capacities.append(int(in_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.sink()))\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\n # and cost 0.\n for v in self:\n # process internal verts only, since we assume source and sink have\n # no in and out edges respectively\n if v != self.source() and v != self.sink():\n # compute a-exc(v)\n in_weight = 0\n for in_arc in self.in_arcs_lists[v]:\n in_weight += self.arc_info[in_arc][\"weight\"]\n out_weight = 0\n for out_arc in self.out_arcs_lists[v]:\n out_weight += self.arc_info[out_arc][\"weight\"]\n a_exc = out_weight - in_weight\n if a_exc < 0:\n # add edge (s', v)\n start_nodes.append(s_prime)\n end_nodes.append(v)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n v,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (v, t')\n start_nodes.append(v)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n v,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # process x node\n a_exc = out_weight_x - in_weight_x\n if a_exc < 0:\n # add edge (s', x)\n start_nodes.append(s_prime)\n end_nodes.append(x)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n x,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (x, t')\n start_nodes.append(x)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n x,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # we must send flow of A from s_prime to t_prime\n supplies = [0]*(len(self) + 3)\n supplies[s_prime] = int(A)\n supplies[t_prime] = int(-A)\n # Instantiate a SimpleMinCostFlow solver.\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\n # Add each arc.\n for i in range(len(start_nodes)):\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\n end_nodes[i], capacities[i], unit_costs[i])\n # Add node supplies\n for i in range(0, len(supplies)):\n min_cost_flow.SetNodeSupply(i, supplies[i])\n # Find the minimum cost flow between node s' and t'.\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\n print('Minimum cost:', min_cost_flow.OptimalCost())\n print('')\n print(' Arc Flow / Capacity Cost')\n for i in range(min_cost_flow.NumArcs()):\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\n print('%1s -> %1s %3s / %3s %3s' % (\n min_cost_flow.Tail(i),\n min_cost_flow.Head(i),\n min_cost_flow.Flow(i),\n min_cost_flow.Capacity(i),\n cost))\n # update arcs\n start = min_cost_flow.Tail(i)\n destin = min_cost_flow.Head(i)\n if start != s_prime and \\\n start != t_prime and \\\n start != x and \\\n destin != s_prime and \\\n destin != t_prime and \\\n destin != x:\n # if forward, increase flow. otherwise decrease.\n print(\"Processing edge ({}, {})\".format(start, destin))\n if start < destin:\n sup_flow = min_cost_flow.Flow(i)\n else:\n sup_flow = -min_cost_flow.Flow(i)\n temp_start = start\n start = destin\n destin = temp_start\n print(\"Has become ({}, {}) with sup {}\".format(start,\n destin,\n sup_flow))\n arc = self.get_arc(start, destin)\n if (sup_flow != 0) or (\"lower_bound\" not in \\\n self.arc_info[arc].keys()):\n print(\"We should add this\")\n old_flow = self.arc_info[arc][\"weight\"]\n new_flow = old_flow + sup_flow\n self.arc_info[arc][\"weight\"] = int(new_flow)\n print(\"Edge ({},{}) weight is changed from {} to {}\".format(\n start,\n destin,\n old_flow,\n new_flow))\n else:\n print('There was an issue with the min cost flow input.')\n #self.check_conservation_of_flow() # check that solution is valid","def find_ports(self, lines):\n ports = []\n left = None\n self.dists = []\n for line in lines:\n if left is None:\n if self.is_left(line):\n left = self.mid(line)\n else:\n if not self.is_left(line):\n ports.append(int(left[0] + self.mid(line)[0]) // 2)\n self.dists.append(left[0] - self.mid(line)[0])\n left = None\n # print(ports)\n return ports","def bfs_nodes_generator(graph, source, reverse=...):\n ...","def max_flow(self, source, sink):\n\n path = self.valid_path(source, sink, [])\n\n while path:\n # get the maximum possible flow that can be taken from this path:\n max_flow = min([edge.capacity for edge in path])\n for edge in path:\n self.edges[edge] += max_flow\n path = self.valid_path(source, sink, [])\n\n # Compute all the flows from the neighbors of source:\n return sum([self.edges[edge] for edge in self.adjacents[source]])","def nodes_ratio(data: Data, position_against_soma=None, node_types=None, filter_layers=None):\n soma = data.morphology.get_soma()\n if position_against_soma=='above':\n criterion=lambda nod:((nod['type'] in node_types) if node_types is not None else True) and nod['y']<soma['y']\n elif position_against_soma=='below':\n criterion=lambda nod:((nod['type'] in node_types) if node_types is not None else True) and nod['y']>soma['y']\n else:\n criterion=lambda nod:nod['type'] in node_types if node_types is not None else True\n num_type_nodes = data.morphology.get_node_by_types(node_types)\n if filter_layers and isinstance(filter_layers, list):\n result = {}\n for layer in filter_layers:\n filter_layer_depth = data.reference_layer_depths.get(layer)\n y_min, y_max, is_scale = filter_layer_depth.pia_side, filter_layer_depth.wm_side, filter_layer_depth.scale\n if is_scale:\n selected_nodes = data.morphology.filter_nodes(lambda nod: criterion(nod) and y_min<nod['y']<y_max)\n else:\n selected_nodes = data.morphology.filter_nodes(lambda nod: criterion(nod) and nod['y']>y_min)\n result[layer]=len(selected_nodes)/len(num_type_nodes)\n return result\n else:\n selected_nodes = data.morphology.filter_nodes(criterion)\n return len(selected_nodes)/len(num_type_nodes)","def get_fraction_links_active(self):\n active_links = 0\n for (a,b) in self.model.model.edges_iter():\n (a_id, a_traits) = self.model.get_agent_by_id(a)\n (b_id, b_traits) = self.model.get_agent_by_id(b)\n prob = analysis.calc_probability_interaction_axelrod(a_traits, b_traits)\n if prob > 0.0 and prob < 1.0:\n #log.debug(\"active link (%s %s) prob: %s a_trait: %s b_trait: %s\", a_id, b_id, prob, a_traits, b_traits)\n active_links += 1\n num_links_total = self.model.model.number_of_edges()\n #log.debug(\"active links: %s total links: %s\", active_links, num_links_total)\n fraction_active = float(active_links) / num_links_total\n return fraction_active","def find_sharpest_fork(nodes):\n pair_list = []\n Dis = np.array([])\n for n in nodes:\n if n.parent is not None:\n if n.parent.parent is not None:\n a = n.parent.children\n if(isinstance(a, list)):\n if(len(a)==2):\n n1 = a[0]\n n2 = a[1]\n if(len(n1.children) == 0 and len(n2.children) == 0):\n pair_list.append([n1 , n2])\n dis = LA.norm(a[0].xyz - a[1].xyz,2)\n Dis = np.append(Dis,dis)\n if(len(Dis)!= 0):\n (b,) = np.where(Dis == Dis.min())\n sharpest_pair = pair_list[b[0]]\n distance = Dis.min()\n else:\n sharpest_pair = [0,0]\n distance = 0.\n return sharpest_pair, distance","def bfs_paths(self, start: str, goal: str) -> List[Path]:\n queue = [(start, [start])]\n while queue:\n (node, path) = queue.pop(0)\n if node not in self.graph:\n yield []\n for _next in set(self.graph[node]) - set(path):\n if _next == goal:\n yield path + [_next]\n elif _next in self.graph:\n queue.append((_next, path + [_next]))","def get_all_social_paths(self, user_id): #each user v v each path V V\n # output example- {1: [1], 8: [1, 8], 10: [1, 10], 5: [1, 5], 2: [1, 10, 2], 6: [1, 10, 6], 7: [1, 10, 2, 7]}\n visited = {} # Note that this is a dictionary, not a set\n # Need to do a bfs using the user id\n # first step is to traverse the graph and record all the vertices as keys in visited using bft\n # then take those keys and use bfs on each, using user_id as the starting node and and the key as\n # the destination node\n\n # Modification of BFT\n # create an empty dict\n # q = Queue()\n q = []\n\n # init enqueue the starting node\n q.append(user_id)\n\n while len(q) > 0:\n # Dequeue the first item\n v = q.pop(0)\n # If it's not been visited:\n if v not in visited:\n # Mark as visited (i.e. add to the visited set)\n visited[v] = []\n\n # Do something with the node\n print(f\"Visited {v}\")\n\n # Add all neighbors to the queue\n for next_vert in self.friendships[v]:\n q.append(next_vert)\n\n # once visited is filled, then we start the bfs\n #print('vv',visited)\n possible_paths = {}\n #run a bfs for each key in visited\n for v in visited:\n possible_paths[v] = []\n \n if v == user_id:\n visited[v] = [user_id]\n\n path = []\n while len(path) < len(visited):\n\n # Add all neighbors to the queue\n for next_vert in self.friendships[v]:\n print(possible_paths[v])\n # copy the path\n # temp_path = list(path)\n # temp_path.append(next_vert)\n # add path to possible_paths\n path.append(next_vert)\n\n possible_paths[v].append(path) # HAVE TO USE QUEUE OR STACK, THEY ENSURE THE NEIGHBORS\n # FOLLOW THE CORRECT ORDER WHEN LOOPING \n\n if v == path[-1]:\n \n # IF SO, RETURN PATH\n visited[v] = path\n break\n\n # for x in visited:\n # bfs(user_id, x)\n # visited[x].add(path)\n \n print('pct of total users in network', len(visited[1])/len(visited))\n print('degrees of separation', len(visited[1]) - 1)\n return visited","def findrelations(planet, comingFrom, relations, borders):\n transfers = []\n transfersPath = 0\n \n relations = []\n for i in relations:\n if planet in i:\n # both orbits and centers can be saved except itself and the one coming from\n for j in i: \n if j not in (planet, comingFrom):\n relations.append(j)\n \n for rel in relations:\n if rel == \"SAN\":\n return transfers\n elif rel not in borders:\n transfers +=1\n transfers += findrelations(rel, comingFrom, relations, borders)\n \n transfers.append(transfersPath-1)\n return transfers","def _get_full_graph(self):","def path_to_actor(self, source, target):\r\n #shortest path\r\n path = nx.shortest_path(self.graph, source, target)\r\n #shortest path length....\r\n len_path = nx.shortest_path_length(self.graph, source, target)\r\n return path, len_path/2","def get_fraction_links_active(self):\n active_links = 0\n for (a,b) in self.model.model.edges_iter():\n (a_id, a_traits) = self.model.get_agent_by_id(a)\n (b_id, b_traits) = self.model.get_agent_by_id(b)\n prob = analysis.calc_probability_interaction_extensible(a_traits, b_traits)\n if prob > 0.0 and prob < 1.0:\n #log.debug(\"active link (%s %s) prob: %s a_trait: %s b_trait: %s\", a_id, b_id, prob, a_traits, b_traits)\n active_links += 1\n num_links_total = self.model.model.number_of_edges()\n #log.debug(\"active links: %s total links: %s\", active_links, num_links_total)\n fraction_active = float(active_links) / num_links_total\n return fraction_active","def createBridgeSets(blocksize,operating,MPSS):\n sets = tuple()\n xul = blocksize[0]-operating\n xdl = operating\n yul = int(blocksize[0]/2+operating)\n ydl = int(blocksize[0]/2-operating)\n xts = xul\n xbs = xdl\n for i in range(MPSS):\n sets+=(tuple(product(numpy.arange(xdl,xul,1),numpy.arange(ydl,yul,1))),)\n xdl+=operating\n xul-=operating\n ydl-=operating\n yul+=operating\n return sets,sets[::-1]","def detect_splits(self):\n logg.info(' abstracted graph will have {} nodes'.format(self.n_splits+1))\n indices_all = np.arange(self.X.shape[0], dtype=int)\n segs = [indices_all]\n if False: # this is safe, but not compatible with on-the-fly computation\n tips_all = np.array(np.unravel_index(np.argmax(self.Dchosen), self.Dchosen.shape))\n else:\n if self.iroot is not None:\n tip_0 = np.argmax(self.Dchosen[self.iroot])\n else:\n tip_0 = np.argmax(self.Dchosen[0]) # just a random index, here fixed to \"0\"\n tips_all = np.array([tip_0, np.argmax(self.Dchosen[tip_0])])\n # we keep a list of the tips of each segment\n segs_tips = [tips_all]\n if self.clusters_precomputed_names:\n self.segs_names_original = [', '.join(self.clusters_precomputed_names)]\n segs_undecided = [True]\n segs_adjacency = [[]]\n segs_distances = np.zeros((1, 1))\n segs_adjacency_nodes = [{}]\n # logg.info(' do not consider groups with less than {} points for splitting'\n # .format(self.min_group_size))\n for ibranch in range(self.n_splits):\n if self.clusters == 'unconstrained_segments':\n iseg, new_tips = self.select_segment(segs, segs_tips, segs_undecided)\n if iseg == -1:\n logg.info('... partitioning converged')\n break\n logg.info('... branching {}:'.format(ibranch + 1),\n 'split group', iseg)\n segs_distances = self.do_split(segs, segs_tips,\n segs_undecided,\n segs_adjacency,\n segs_distances,\n iseg, new_tips)\n else:\n logg.msg(' split', ibranch + 1, v=4)\n stop, segs_distances = self.do_split_constrained(segs, segs_tips,\n segs_adjacency,\n segs_adjacency_nodes,\n segs_distances)\n if stop: break\n\n # segments\n self.segs = segs\n self.segs_tips = segs_tips\n self.segs_sizes = []\n for iseg, seg in enumerate(self.segs): self.segs_sizes.append(len(seg))\n\n # the full, unscaled adjacency matrix\n self.segs_adjacency_full_attachedness = 1/segs_distances\n # if self.attachedness_measure == 'connectedness':\n # norm = np.sqrt(np.multiply.outer(self.segs_sizes, self.segs_sizes))\n # self.segs_adjacency_full_attachedness /= norm\n self.segs_adjacency_full_confidence, self.segs_adjacency_tree_confidence \\\n = self.compute_adjacency_confidence(\n self.segs_adjacency_full_attachedness,\n segs_adjacency,\n self.tree_based_confidence)\n np.fill_diagonal(self.segs_adjacency_full_attachedness, 0)","def transmission (graph, r=.5, m=.5):\n\n routes = r*nx.adjacency_matrix(graph)\n medicn = m*sp.eye(nx.number_of_nodes(graph))\n\n return routes + medicn","def get_GNS_cut(self):\n # we build the optimization around the casted digraph instead of multidigraph\n # for simplicity\n G = self.base_digraph\n s_1 = self.sources[0]\n s_2 = self.sources[1]\n t_1 = self.destinations[0]\n t_2 = self.destinations[1]\n edges = G.edges()\n nodes = G.nodes()\n\n try:\n\n # Great an gurobi instance of the optimization model\n m = Model(\"GNS\")\n m.setParam('OutputFlag', False)\n\n x_v = {}\n # vertex variables for s_1, t_1 cut\n for v in nodes:\n x_v[v] = m.addVar(vtype=GRB.BINARY)\n\n x_e = {}\n # edge variables for s_1, t_1 cut\n for (u,v) in edges:\n x_e[u,v] = m.addVar(vtype=GRB.BINARY)\n\n y_v = {}\n # vertex variables for s_2, t_2 cut\n for v in nodes:\n y_v[v] = m.addVar(vtype=GRB.BINARY)\n\n y_e = {}\n # edge variables for s_2, t_2 cut\n for (u,v) in edges:\n y_e[u,v] = m.addVar(vtype=GRB.BINARY)\n\n z_v = {}\n # vertex variables for s_2, t_1 cut\n for v in nodes:\n z_v[v] = m.addVar(vtype=GRB.BINARY)\n\n z_e = {}\n # edge variables for s_2, t_1 cut\n for (u,v) in edges:\n z_e[u,v] = m.addVar(vtype=GRB.BINARY)\n\n e = {}\n # GNS indicator variable\n for (u,v) in edges:\n e[u,v] = m.addVar(vtype=GRB.BINARY, obj=G[u][v]['capacity'])\n\n # Done with decision variable creation\n # update model\n m.update()\n\n # Constraints\n # 1. Constraints for s_1 - t_1 cut\n for (u,v) in edges:\n if (u,v) == (s_1, t_1):\n m.addConstr(x_e[u,v] >= 1)\n elif u == s_1:\n m.addConstr(x_v[v] + x_e[u,v] >= 1)\n elif v == t_1:\n m.addConstr(-x_v[u] + x_e[u,v] >= 0)\n else:\n m.addConstr(x_v[v] - x_v[u] + x_e[u,v] >= 0)\n\n # 2. Constraints for s_2 - t_2 cut\n for (u,v) in edges:\n if (u,v) == (s_2, t_2):\n m.addConstr(y_e[u,v] >= 1)\n elif u == s_2:\n m.addConstr(y_v[v] + y_e[u,v] >= 1)\n elif v == t_2:\n m.addConstr(-y_v[u] + y_e[u,v] >= 0)\n else:\n m.addConstr(y_v[v] - y_v[u] + y_e[u,v] >= 0)\n\n # 3. Constraints for s_2 - t_1 cut\n for (u,v) in edges:\n if (u,v) == (s_2, t_1):\n m.addConstr(z_e[u,v] >= 1)\n elif u == s_2:\n m.addConstr(z_v[v] + z_e[u,v] >= 1)\n elif v == t_1:\n m.addConstr(-z_v[u] + z_e[u,v] >= 0)\n else:\n m.addConstr(z_v[v] - z_v[u] + z_e[u,v] >= 0)\n\n # 4. Constraints for e[u,v] >= max(x_e[u,v], y_e[u,v], z_e[u,v])\n for (u,v) in edges:\n m.addConstr(e[u,v] >= x_e[u,v])\n m.addConstr(e[u,v] >= y_e[u,v])\n m.addConstr(e[u,v] >= z_e[u,v])\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n print \"Min GNS cut value = \" + str(m.objVal)\n print \"GNS cut edges:\"\n\n for u,v in edges:\n if e[u,v].x != 0:\n print (u,v)\n print \"s1-t1 cut edges in GNS:\"\n for u,v in edges:\n if x_e[u,v].x != 0:\n print (u,v)\n\n print \"s2-t2 cut edges in GNS:\"\n for u,v in edges:\n if y_e[u,v].x != 0:\n print (u,v)\n\n print \"s2-t1 cut edges in GNS:\"\n for u,v in edges:\n if z_e[u,v].x != 0:\n print (u,v)\n else:\n # something went wrong...err...\n print \"Something was wrong\"\n\n except GurobiError:\n print ('Error report from Gurobi')","def get_path(self, sim, app_name, message, topology_src, alloc_DES, alloc_module, traffic, from_des):\n node_src = topology_src\n DES_dst = alloc_module[app_name][message.dst]\n\n # print (\"GET PATH\")\n # print (\"\\tNode _ src (id_topology): %i\" % node_src)\n # print (\"\\tRequest service: %s \" % message.dst)\n # print (\"\\tProcess serving that service: %s \" % DES_dst)\n\n bestPath = []\n bestDES = []\n min_path_size = float('inf')\n myDigraph = graph2digraph(sim.topology.G)\n\n for des in DES_dst: ## In this case, there are only one deployment\n dst_node = alloc_DES[des]\n print (\"\\t Looking the path to id_node: %i\" % dst_node)\n\n path = list(nx.shortest_path(myDigraph, source=node_src, target=dst_node, weight='BW'))\n actual_path_size = nx.shortest_path_length(myDigraph, source=node_src, target=dst_node, weight='BW')\n\n # Calculo do fluxo maximo no grafo desde 1 ate 6\n # flow_value, flow_dict = list(nx.maximum_flow(myDigraph, _s=0, _t=6, capacity=\"BW\"))\n # print(\"MAXFLOW VALUE: \", flow_value)\n # print(\"MAXFLOW DICT: \", flow_dict)\n\n print (\"\\t\\t candidate to best path: \" + str(path) + \" Size = \" + str(actual_path_size))\n\n if actual_path_size < min_path_size:\n min_path_size = actual_path_size\n minPath = path\n bestDES = des\n\n bestPath = [minPath]\n bestDES = [des]\n print (\"best path is: \", bestPath, \" with weigth \", min_path_size)\n print \"---------------------------------------------------------\"\n return bestPath, bestDES","def greedy(self):\n # for each node, find the incoming link with the highest score.\n max_scores = {}\n max_sources = {}\n for source, target in self.iteredges():\n score = self.get_score(source, target)\n max_score = max_scores.get(target)\n if max_score is None or score > max_score:\n max_scores[target] = score\n max_sources[target] = source\n # then build a graph out of just these links.\n succs = dict((n, []) for n in self)\n for target, source in max_sources.items():\n succs[source].append(target)\n return Digraph(succs, self.get_score, self.get_label)","def internal_link_density(self, node_list):\n N = len(node_list)\n n_links = self.number_internal_links(node_list)\n if self.directed:\n return float(n_links) / (N * (N - 1))\n else:\n return 2 * float(n_links) / (N * (N - 1))","def __edgeRouter(self):\r\n def getEndpoint(nodeTuple, pointList, direction, isReversedEdge):\r\n \"\"\" Gets the nearest arrow endpoint. Handles edge reversal \"\"\"\r\n if((direction == 'start' and not isReversedEdge)\r\n or (direction == 'end' and isReversedEdge)): \r\n endNode = nodeTuple[0]\r\n if(isReversedEdge):\r\n ix = -2\r\n iy = -1\r\n else:\r\n ix = 0\r\n iy = 1\r\n else: \r\n endNode = nodeTuple[1]\r\n if(isReversedEdge):\r\n ix = 0\r\n iy = 1\r\n else:\r\n ix = -2 \r\n iy = -1 \r\n \r\n # Is it connected to a named port!?!\r\n if(endNode.isConnectedByNamedPort(edgeObject)):\r\n handler = endNode.getConnectedByNamedPortHandler(nodeTuple[2]) \r\n return dc.coords(handler)[:2]\r\n \r\n # Not a named port...\r\n return list(endNode.getClosestConnector2Point( endNode, pointList[ix], \r\n pointList[iy])) \r\n \r\n \r\n \r\n #todo: improve method for spline arrows + add comments + optimize?\r\n print '----------------Dummy Edge Routing-----------------'\r\n for dummyEdge in NodeWrapper.ID2LayerEdgeDict.keys():\r\n \r\n dummyList = NodeWrapper.ID2LayerEdgeDict[dummyEdge]\r\n dummyNode = dummyList[0]\r\n dummyChild = dummyNode.children.keys()[0]\r\n linkFlagList = dummyNode.children[dummyChild]\r\n \r\n # Real nodes at start/end of the edge\r\n edgeSourceNode = dummyNode.parents.keys()[0]\r\n edgeSourceNode = edgeSourceNode.getASGNode().graphObject_\r\n dummyNode = dummyList[-1]\r\n edgeTargetNode = dummyNode.children.keys()[0]\r\n #print 'Dummy edge number', dummyEdge,\r\n #print dummyList[0].parents.keys()[0].getName(), edgeTargetNode.getName()\r\n edgeTargetNode = edgeTargetNode.getASGNode().graphObject_\r\n nodeTuple = [edgeSourceNode, edgeTargetNode, None]\r\n \r\n # Some edges are internally reversed to break cycles, when drawing\r\n # this must be taken into account\r\n isReversedEdge = False\r\n edgesToRoute = []\r\n for linkNode, isReversed in linkFlagList:\r\n edgesToRoute.append(linkNode)\r\n if(isReversed):\r\n isReversedEdge = True\r\n \r\n # Get all the points the edge must pass through (sorted by layer order)\r\n dummyList.sort(lambda a, b: cmp(a.getLayer(), b.getLayer()))\r\n if(isReversedEdge):\r\n dummyList.reverse()\r\n sortedDummyRouteList = []\r\n for node in dummyList:\r\n sortedDummyRouteList += node.getEdgePosition()\r\n \r\n # Set the coordinates of the edge directly \r\n # This is complicated by the fact that AToM3 treats edges as two\r\n # segments that join poorly (for spline arrows)\r\n for edgeObject in edgesToRoute: \r\n dc = edgeObject.graphObject_.dc\r\n linkObj = edgeObject.graphObject_ \r\n tag = linkObj.tag\r\n \r\n if(isReversedEdge):\r\n inPoint = dc.coords( tag + \"2ndSeg0\" )[:2]\r\n outPoint = dc.coords( tag + \"1stSeg0\" )[:2]\r\n else:\r\n inPoint = dc.coords( tag + \"1stSeg0\" )[:2]\r\n outPoint = dc.coords( tag + \"2ndSeg0\" )[:2]\r\n \r\n #print 'Dummy route', sortedDummyRouteList\r\n numPoints = len(sortedDummyRouteList) / 2\r\n # Add 2 extra control points for odd case (to make splines nice)\r\n if(numPoints % 2 == 1):\r\n if(numPoints == 1):\r\n center = sortedDummyRouteList\r\n else:\r\n start = sortedDummyRouteList[:numPoints - 1]\r\n end = sortedDummyRouteList[numPoints + 1:]\r\n center = sortedDummyRouteList[numPoints - 1:numPoints + 1]\r\n \r\n if(not isReversedEdge):\r\n newMid1 = [center[0], center[1] - 20]\r\n newMid2 = [center[0], center[1] + 20]\r\n else:\r\n newMid2 = [center[0], center[1] - 20]\r\n newMid1 = [center[0], center[1] + 20]\r\n \r\n \r\n if(numPoints == 1):\r\n sortedDummyRouteList = newMid1 + center + newMid2 \r\n else:\r\n sortedDummyRouteList = start + newMid1 + center + newMid2 + end\r\n centerIndex = numPoints - 1 + 2\r\n \r\n # Add 1 extra control point for even case (to make splines nice)\r\n else:\r\n start = sortedDummyRouteList[:numPoints]\r\n end = sortedDummyRouteList[numPoints:]\r\n center = [start[-2] + (end[0] - start[-2]) / 2, \r\n start[-1] + (end[1] - start[-1]) / 2]\r\n sortedDummyRouteList = start + center + end \r\n centerIndex = numPoints\r\n \r\n # Now I know where the center is... so lets move the center object\r\n # Is the edge object a hyperlink?\r\n if(len(edgeObject.in_connections_ + edgeObject.out_connections_) > 2):\r\n fromObjs = []\r\n for semObj in edgeObject.in_connections_:\r\n fromObjs.append(semObj.graphObject_)\r\n toObjs = []\r\n for semObj in edgeObject.out_connections_:\r\n toObjs.append(semObj.graphObject_)\r\n optimizerHyperLink(dc, linkObj, fromObjs, toObjs, 0, 0, 0, center )\r\n continue\r\n \r\n else:\r\n linkObj.moveTo(* center)\r\n \r\n # Go through the 2 segments in the link\r\n nodeTuple[2] = edgeObject\r\n for connTuple in linkObj.connections:\r\n itemHandler = connTuple[0]\r\n direction = connTuple[1]\r\n \r\n if( direction ): \r\n inPoint = getEndpoint(nodeTuple, sortedDummyRouteList,\r\n 'start', isReversedEdge)\r\n\r\n segCoords = inPoint + sortedDummyRouteList[:centerIndex+2]\r\n else: \r\n outPoint = getEndpoint(nodeTuple, sortedDummyRouteList,\r\n 'end', isReversedEdge) \r\n segCoords = sortedDummyRouteList[centerIndex:] + outPoint\r\n segCoords = self.__reverseCoordList(segCoords)\r\n \r\n # Applies the changed coords to the canvas\r\n dc.coords( * [itemHandler] + segCoords ) \r\n \r\n # This may change the associated link drawings: \r\n # move them to the new point \r\n if( direction ):\r\n linkObj.updateDrawingsTo(inPoint[0], inPoint[1], itemHandler, \r\n segmentNumber=1)\r\n else:\r\n linkObj.updateDrawingsTo(outPoint[0], outPoint[1], itemHandler, \r\n segmentNumber=2)","def _mout_edges(nodes):\n n = nodes.shape[0]\n edges = []\n for i in range(0, n - 1):\n for j in range(i, n):\n if abs(nodes[i, 0] - nodes[j, 0]) > 1:\n break\n elif abs(nodes[i, 0] - nodes[j, 0]) == 1 and \\\n abs(nodes[i, 1] - nodes[j, 1]) == 0:\n edges.append([i, j])\n elif abs(nodes[i, 1] - nodes[j, 1]) == 1:\n edges.append([i, j])\n return edges","def naiveGlobalRouting(self):\n for e_list in self.s2e.values():\n for e in e_list:\n slot_path = []\n src_slot = self.v2s[e.src]\n dst_slot = self.v2s[e.dst]\n slot_path.append(src_slot)\n\n curr = src_slot\n len_x = src_slot.getLenX()\n len_y = src_slot.getLenY()\n\n # first go in X direction\n x_diff = curr.getPositionX() - dst_slot.getPositionX()\n if x_diff:\n dir = 'LEFT' if x_diff > 0 else 'RIGHT'\n for i in range(int(abs(x_diff/len_x))):\n curr = self.slot_manager.createSlotForRouting(curr.getNeighborSlotName(dir))\n slot_path.append(curr)\n\n y_diff = curr.getPositionY() - dst_slot.getPositionY()\n if y_diff:\n dir = 'DOWN' if y_diff > 0 else 'UP'\n for i in range(int(abs(y_diff/len_y))):\n curr = self.slot_manager.createSlotForRouting(curr.getNeighborSlotName(dir))\n slot_path.append(curr)\n \n assert curr == dst_slot\n \n slot_path = slot_path[1:-1] # exclude the src and the dst\n logging.info(f'{e.name}: {self.v2s[e.src].getName()} -> {self.v2s[e.dst].getName()} : ' + ' '.join(s.getName() for s in slot_path))\n self.e_name2path[e.name] = slot_path","def bandwidth_share(self, nodes_efficiency: Dict[str, float]) -> Dict[str, float]:\n pass","def run_dfs(self,s):\n if self.verbose: print('entering run_dfs with s = ',s)\n new_states = [self.succ(s,a) for a in self.actions(s)]\n results = []\n\n for ns in new_states:\n if self.verbose: print('considering new state = ',ns)\n end = self.is_end(ns)\n if end:\n result = self.result(ns)\n if result is not None:\n results.append(result)\n else:\n results += self.run_dfs(ns)\n return results","def get_network_ratio(df, edges, initial_buffer=500):\n\n # intersection-based join\n buff = edges.buffer(0.01) # to avoid floating point error\n inp, res = buff.sindex.query_bulk(df.geometry, predicate=\"intersects\")\n intersections = (\n df.iloc[inp]\n .reset_index(drop=True)\n .intersection(buff.iloc[res].reset_index(drop=True))\n )\n mask = intersections.area > 0.0001\n intersections = intersections[mask]\n inp = inp[mask]\n lengths = intersections.area\n grouped = lengths.groupby(inp)\n totals = grouped.sum()\n ints_vect = []\n for name, group in grouped:\n ratios = group / totals.loc[name]\n ints_vect.append({res[item[0]]: item[1] for item in ratios.iteritems()})\n\n edge_dicts = pd.Series(ints_vect, index=totals.index)\n\n # nearest neighbor join\n nans = df.index.difference(edge_dicts.index)\n buffered = df.iloc[nans].buffer(initial_buffer)\n additional = []\n for orig, geom in zip(df.iloc[nans].geometry, buffered.geometry):\n query = edges.sindex.query(geom, predicate=\"intersects\")\n b = initial_buffer\n while query.size == 0:\n query = edges.sindex.query(geom.buffer(b), predicate=\"intersects\")\n b += initial_buffer\n additional.append({edges.iloc[query].distance(orig).idxmin(): 1})\n\n additional = pd.Series(additional, index=nans)\n ratios = pd.concat([edge_dicts, additional]).sort_index()\n result = pd.DataFrame()\n result[\"edgeID_keys\"] = ratios.apply(lambda d: list(d.keys()))\n result[\"edgeID_values\"] = ratios.apply(lambda d: list(d.values()))\n result.index = df.index\n return result","def sage_graph(self):\n self.fe.load_cache()\n edges = []\n is_bipartite = self.variant.is_bipartite()\n for X in self.L:\n for Y in self.L:\n a = self.op_norm(X, Y)\n if not self.K.is_zero(a):\n for c in self.K.unit_group:\n d = a - c\n if X != Y or c < d or is_bipartite:\n edges.append(((X, c, False), (Y, d, is_bipartite)))\n if X == Y and not is_bipartite:\n break\n return sage.all.Graph(edges)","def construct_fast_graph_connection(coord_list, radie):\n\n connection_distance = []\n connection = []\n coord_list_tree = scipy.spatial.cKDTree(coord_list)\n for j, data in enumerate(coord_list):\n '''save nodes which are in range'''\n connections_ckd = coord_list_tree.query_ball_point(data, radie)\n for i in connections_ckd:\n #only save upper half of the matrix\n if i > j:\n #save the connection\n connection.append([j, i])\n #save the relative distance of the nodes\n connection_distance.append(np.hypot(coord_list[i,0]-data[0], coord_list[i,1]-data[1]))\n\n connection_distance = np.array(connection_distance)\n connection = np.array(connection)\n\n\n return connection, connection_distance","def test_find_path_dfs():\n g = Graph()\n node_1 = Node({'A':['B','C']})\n g.add(node_1)\n node_2 = Node({'B':['C','D']})\n g.add(node_2)\n node_3 = Node({'C':['D']})\n g.add(node_3)\n node_4 = Node({'D':['C']})\n g.add(node_4)\n node_5 = Node({'E':['C']})\n g.add(node_5)\n\n # zero path between node_1 and node_5\n path_0 = g.find_path_dfs(node_1, node_5)\n assert path_0 == None\n\n # only one path between node_5 and node_4\n path_1 = g.find_path_dfs(node_5, node_4)\n assert [ node.name for node in path_1 ] == [ node_5.name, node_3.name, node_4.name ]\n\n # three paths between node_1 and node_3, verify anyone of the three is returned\n path_3 = g.find_path_dfs(node_1, node_3)\n assert [ node.name for node in path_3 ] == [ node_1.name, node_2.name, node_3.name ] or \\\n [ node.name for node in path_3 ] == [ node_1.name, node_2.name, node_4.name, node_3.name ] or \\\n [ node.name for node in path_3 ] == [ node_1.name, node_3.name ]","def trapezium_rule(f, m, x, a, b, n):\n h = (b-a)/float(n)\n s = 0.5*(f(m, x, a) + f(m, x, b))\n for i in range(n):\n s = s + f(m, x, a + i*h)\n return h*s","def compute_equal_flow_allocations(target_graph, K=3):\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n flow_allocation_seed_number = 0xDEAD_BEEF\n np.random.seed(flow_allocation_seed_number)\n flows = []\n for node in target_graph.nodes:\n possible_destination_nodes = set(target_graph.nodes) - set([node])\n [destination_node] = np.random.choice(list(possible_destination_nodes), 1, replace=False)\n # shortest_paths = all_shortest_paths(target_graph, node, destination_node.item())\n shortest_paths = sorted(nx.all_simple_paths(target_graph, node, destination_node.item(),\n cutoff=3),\n key=lambda p: len(p))\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\n the_flow = Flow( source_node = node\n , destination_node = destination_node.item()\n , flow_tx_rate = 10.0\n , paths = k_shortest_paths\n , splitting_ratio = [1/K]*K\n )\n flows.append(the_flow)\n \n return flow_allocation_seed_number, flows","def get_urls(*params: str, num_of_links: int = 1) -> list:\n urls = []\n try:\n for i in range(num_of_links):\n url = \"https://finviz.com/screener.ashx?v=111\"\n codes = ','.join(rts_codes[len(rts_codes)*(num_of_links - i - 1)//num_of_links:(len(rts_codes)*(num_of_links - i)//num_of_links)])\n payload = {\"FT\": 2,\"f\": params,\"t\": codes}\n req = requests.get(url, params=payload)\n if len(req.url) > 2900:\n urls = []\n num_of_links += 1\n urls = get_urls(*params, num_of_links=num_of_links)\n else:\n urls.append(req.url)\n return (urls)\n except Exception as e:\n print (e)\n return None","def pair_frame(captured_file, frame_seq):\n rid = 0\n all_frame = {}\n fs_relation = {} # frame_stream_relation, mapping from stream number to one or more rid\n get_pairing = \"tshark -2 -r {} -R '' -Y 'frame.number > 0 && http.request' -T fields -e tcp.stream -e frame.number -e http.response_in\"\n \n # Run get_pairing command\n pairs = run_command(get_pairing.format(captured_file), False)\n\n # Associate each request and response node with its frame number in a dict\n for i in range(0, len(frame_seq)):\n cur_node = frame_seq[i]\n all_frame[cur_node.get_frame()] = cur_node\n \n all_stream = []\n for p in pairs:\n pl = p.decode('utf8').rstrip('\\n').split('\\t')\n cur_sn = int(pl[0]) # current_stream_number\n try:\n fs_relation[cur_sn]\n except KeyError:\n fs_relation[cur_sn] = []\n all_stream.append(cur_sn)\n fs_relation[cur_sn].append(rid)\n\n req_fn = int(pl[1]) # request_frame\n all_frame[req_fn].set_req()\n all_frame[req_fn].set_rid(rid)\n\n try:\n res_fn = int(pl[2]) # response_frame\n all_frame[res_fn].set_res()\n all_frame[res_fn].set_rid(rid)\n except ValueError:\n # Handle request without response here\n pass\n\n rid += 1\n\n return frame_seq, fs_relation, all_stream","def _split_forced(self, node):\n # compute the split\n _vec = 0\n sorted_idxs = np.argsort(self.E[node.ids, _vec]).squeeze()\n n = len(sorted_idxs) // 2\n _lids = node.ids[sorted_idxs[:n]]\n _rids = node.ids[sorted_idxs[n:]]\n # compute the score of the new tubes only\n _sl = self.get_tube_score(_lids)\n _sr = self.get_tube_score(_rids)\n # register the split\n node.has_children = True\n node.thresh = np.median(self.E[node.ids, _vec]) # arbitrary\n # Note: median would not ensure equal size (because of duplicate values)\n left = SpectralNode(_lids, _vec, score=_sl, name=node.name + \"0\")\n right = SpectralNode(_rids, _vec, score=_sr, name=node.name + \"1\")\n\n return left, right","def a_star_alg(self, p1: int, p2: int, max_level: int = 1000):\r\n \r\n # Create start and end node\r\n start_node = Node(None, p1, self.node_dict[p1])\r\n start_node.g = start_node.h = start_node.f = 0\r\n end_node = Node(None, p2, self.node_dict[p2])\r\n end_node.g = end_node.h = end_node.f = 0\r\n\r\n # Initialize both open and closed list\r\n open_list = []\r\n closed_list = []\r\n\r\n # Add the start node\r\n open_list.append(start_node)\r\n\r\n # Loop until you find the end\r\n level = 0\r\n while len(open_list) > 0 and level < max_level:\r\n level += 1\r\n\r\n # Get the current node (the node in open_list with the lowest cost)\r\n current_node = open_list[0]\r\n current_index = 0\r\n for index, item in enumerate(open_list):\r\n if item.f < current_node.f:\r\n current_node = item\r\n current_index = index\r\n\r\n # Pop current off open list, add to closed list\r\n open_list.pop(current_index)\r\n closed_list.append(current_node)\r\n\r\n # Found the goal\r\n if current_node == end_node:\r\n path = []\r\n distance = current_node.g\r\n current = current_node\r\n while current is not None:\r\n path.append(current.number)\r\n current = current.parent\r\n\r\n return path[::-1], distance # Return reversed path\r\n\r\n # Generate children\r\n children = []\r\n for new_number in self.road_tree[current_node.number]: # Adjacent nodes\r\n new_node = Node(current_node, new_number, self.node_dict[new_number])\r\n children.append(new_node)\r\n\r\n # Loop through children\r\n for child in children:\r\n append_to_open_list = False\r\n\r\n # Create the f, g, and h values\r\n child.g = current_node.g + self.road_dict[(current_node.number, child.number)]\r\n child.h = sqrt((child.x - end_node.x) ** 2 + (child.y - end_node.y) ** 2) / 200\r\n child.f = child.g + child.h\r\n\r\n # Child is already in the closed list\r\n closed_list, append_to_open_list = self.check_in_list(child, closed_list, append_to_open_list)\r\n\r\n # Child is already in the open list\r\n open_list, append_to_open_list = self.check_in_list(child, open_list, append_to_open_list)\r\n\r\n # Add the child to the open list\r\n if append_to_open_list:\r\n open_list.append(child)\r\n\r\n return [], 1e10","def bfs(self, s):\n g = Graph(attr={DIRECTED: True})\n root = self.get_vertex(s)\n root.attributes[DISCOVERED] = True\n q = collections.deque()\n adjacent_type = '+' if DIRECTED in self.attr and self.attr[\n DIRECTED] else None\n # Insert root node in graph and queue\n g.add_vertex(root)\n q.append(s)\n\n while (len(q) > 0):\n v = q.popleft()\n for e in self.get_adjacent_vertices_by_vertex(v, adjacent_type):\n w = self.get_vertex(e)\n if DISCOVERED not in w.attributes or w.attributes[\n DISCOVERED] is False:\n w.attributes[DISCOVERED] = True\n q.append(w.id)\n g.add_vertex(w)\n g.add_edge(edge.Edge(v, e), True)\n return g","def _semiconnected_ramps(slope1=1., slope2=1.) -> cs.Network:\n\n class _Ramp(cs.Simulator):\n \"\"\"Used in tests to mock a simulator\"\"\"\n def __init__(self, slope: Fraction, step_size: Fraction):\n self._step_size = step_size\n self._x = Fraction(0)\n self._slope = slope\n\n @property\n def inputs(self):\n return {'u': sdf.InputPort(float, 1)}\n\n @property\n def outputs(self):\n return {'y': sdf.OutputPort(float, 1)}\n\n def calculate(self, input_tokens):\n self._x += self._slope * self._step_size\n return {'y': [float(self._x)]}\n\n def construct_ramp1(step_size):\n return _Ramp(slope1, step_size)\n\n def construct_ramp2(step_size):\n return _Ramp(slope2, step_size)\n\n slaves = {'Ramp1': construct_ramp1, 'Ramp2': construct_ramp2}\n\n connections = {\n cs.Dst('Ramp1', 'u'): cs.Src('Ramp2', 'y'),\n cs.Dst('Ramp2', 'u'): cs.Src('Ramp1', 'y'),\n }\n return slaves, connections","def find_all_cycles(s,graph):\n\n grph = u.edge_to_list_dict(graph)\n node_cnt = len(grph)\n k = z.Int(\"k\")\n syms = [z.Int('node%s'%i) for i in range(node_cnt)]\n\n # s.add(syms[0] == 0) # start node is a 0\n s.add(k < node_cnt)\n s.add(k > 1)\n\n o = z.Optimize()\n\n # for source, sinks in sgraph.s_adj_list():\n for i in range(node_cnt):\n s.add(syms[i] >= 0)\n s.add(syms[i] <= k)\n s.add(z.Or([syms[j] == ((syms[i] + 1) % k) for j in grph[i]]) == (syms[i] == 0))\n\n\n r = []\n m = []\n\n # o.minimize(z.Sum([syms[i] for i in range(node_cnt)]))\n s.add(z.Product([syms[i] for i in range(node_cnt)]) == 0)\n done = False\n while not done:\n if s.check() == z.sat:\n m = s.model()\n r.append(m)\n s.add(k != m[k])\n else:\n done = True\n\n return r","def calc_lp(self, demands: Demand, routing: Routing) -> float:\n epsilon = self.epsilon\n\n # Create the linear solver with the GLOP backend.\n solver = pywraplp.Solver('flow_utilisation_lp',\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\n\n ## VARIABLES\n # Flow variables, the amount of flow along each edge\n # stored as a list flow_variables[ith_flow][jth_edge]\n flow_variables = []\n for i in range(len(self.commodities)):\n flow_variable_edges = []\n for j in range(len(self.edges)):\n flow_variable_edges.append(\n solver.NumVar(0, solver.infinity(), '({},{})'.format(i, j)))\n flow_variables.append(flow_variable_edges)\n\n ## CONSTRAINTS\n # Flow from source constraint (net flow must equal demand)\n conservation_source_constraints = []\n for i, commodity in enumerate(self.commodities):\n # create constraint\n constraint_i = solver.Constraint(demands[i] - epsilon,\n demands[i] + epsilon,\n '(source,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[0])]:\n # out flow is positive\n constraint_i.SetCoefficient(flow_variables[i][edge_index], 1)\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[0])]:\n # in flow is negative\n constraint_i.SetCoefficient(flow_variables[i][edge_index], -1)\n conservation_source_constraints.append(constraint_i)\n\n # Flow to sink constraint (in flow must equal demand, out must be zero)\n conservation_sink_constraints = []\n for i, commodity in enumerate(self.commodities):\n # create in flow constraint\n constraint_i_in = solver.Constraint(-demands[i] - epsilon,\n -demands[i] + epsilon,\n '(sink_in,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[1])]:\n # in flow is negative\n constraint_i_in.SetCoefficient(flow_variables[i][edge_index],\n -1)\n conservation_sink_constraints.append(constraint_i_in)\n\n constraint_i_out = solver.Constraint(0, 0,\n '(sink_out,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[1])]:\n # out flow is positive\n constraint_i_out.SetCoefficient(flow_variables[i][edge_index],\n 1)\n conservation_sink_constraints.append(constraint_i_out)\n\n # Flow at transit node constraint (net flow must be zero)\n conservation_transit_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.graph.number_of_nodes()):\n if j != commodity[0] and j != commodity[1]:\n # create constraint\n constraint_j = solver.Constraint(-epsilon, +epsilon,\n '(transit,{},{})'.format(i,\n j))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(j)]:\n # out flow is positive\n constraint_j.SetCoefficient(\n flow_variables[i][edge_index],\n 1)\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(j)]:\n # in flow is negative\n constraint_j.SetCoefficient(\n flow_variables[i][edge_index],\n -1)\n constraints_flow_i.append(constraint_j)\n conservation_transit_constraints.append(constraints_flow_i)\n\n # Flow splitting at transit constraints (edge flow must be correct split of\n # in flow)\n splitting_ratio_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.graph.number_of_nodes()):\n # Sink has not such constraint and we handle source differently\n if j != commodity[1] and j != commodity[0]:\n in_edges = [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(j)]\n out_edges = [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(j)]\n\n # separate constraint for split of each out_edge taking into\n # account all in_edges\n for out_edge_index in out_edges:\n # create constraint\n constraint_edge = \\\n solver.Constraint(-epsilon, +epsilon,\n '(split,{},{},{})'.format(\n i, j,\n out_edge_index))\n split_ratio = routing[i][out_edge_index]\n # flow on out edge\n constraint_edge.SetCoefficient(\n flow_variables[i][out_edge_index], 1)\n for in_edge_index in in_edges:\n # should equal sum of flow on all in edges scaled by\n # split ratio\n constraint_edge.SetCoefficient(\n flow_variables[i][in_edge_index],\n -1 * split_ratio)\n constraints_flow_i.append(constraint_edge)\n splitting_ratio_constraints.append(constraints_flow_i)\n\n # Flow splitting at source constraints (edge flow must be correct split of\n # in flow + demand)\n source_splitting_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n in_edges = [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[0])]\n out_edges = [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[0])]\n for out_edge_index in out_edges:\n # create constraint\n split_ratio = routing[i][out_edge_index]\n split_demand = split_ratio * demands[i]\n constraint_edge = \\\n solver.Constraint(split_demand - epsilon,\n split_demand + epsilon,\n '(split,{},{},{})'.format(i, j,\n out_edge_index))\n # flow on out edge\n constraint_edge.SetCoefficient(\n flow_variables[i][out_edge_index], 1)\n for in_edge_index in in_edges:\n # should equal sum of flow on all in edges scaled by split ratio\n constraint_edge.SetCoefficient(\n flow_variables[i][in_edge_index],\n -1 * split_ratio)\n constraints_flow_i.append(constraint_edge)\n source_splitting_constraints.append(constraints_flow_i)\n\n solver.Solve()\n\n result_status = solver.Solve()\n\n utilisation = np.zeros(\n (len(self.commodities), self.graph.number_of_edges()))\n # # extract the actual routing. Useful for debugging, maybe use to bootstrap\n # assignment = np.zeros(\n # (len(self.commodities), self.graph.number_of_edges()))\n\n # if routing is really that bad, just bail and give a sad result\n if result_status == solver.NOT_SOLVED or result_status == solver.INFEASIBLE:\n return 1.0\n\n for i in range(len(self.commodities)):\n for j in range(self.graph.number_of_edges()):\n utilisation[i][j] = flow_variables[i][j].solution_value() / \\\n self.edges[j][2]['weight']\n # assignment[i][j] = flow_variables[i][j].solution_value()\n\n return np.max(np.sum(utilisation, axis=0))","def bfs(self) -> dict:\n distances_graph = {}\n\n # BFS from middle to the robot start point\n start = self.center\n search = self.start\n\n distances_graph[start] = 0\n queue = collections.deque([start])\n\n while True:\n # Get next node\n node = queue.pop()\n\n if node == search:\n # If this is the one we need, search no more\n break\n\n for neighbor in self.graph[node]:\n if neighbor not in distances_graph:\n # If distance to neighbor hasn't been calculated, calculate it\n queue.appendleft(neighbor)\n distances_graph[neighbor] = distances_graph[node] + 1\n\n return distances_graph","def setup_nodes(server_node, road_node, road_segment_point):\n\n # Create working server node data subset excluding unneeded fields\n snode = [{'id': i,\n 'shapeid': item['shapeid'],\n 'x': float(item['x']),\n 'y': float(item['y']),\n 'nearest_pt': None,\n 'nearest_pt_sl_dist': float(\"inf\"),\n 'color_num': (int(item['shapeid']) + CM_OFFSET) % NUM_COLORS}\n for i, item in enumerate(server_node)]\n\n # Create working road node data subset excluding unneeded fields\n # (note: road nodes consist of junctions and road ends)\n rnode = []\n prev_coord = []\n for i, item in enumerate(road_node):\n if [item['x'], item['y']] not in prev_coord: # exclude duplicates\n rnode.append({'id': i,\n 'shapeid': item['shapeid'],\n 'x': float(item['x']),\n 'y': float(item['y']),\n 'best_server': None,\n 'color_num': GREY})\n prev_coord.append([item['x'], item['y']])\n\n # Create working road point data subset excluding unneeded fields\n rpoint = []\n point = 0\n for i in range(len(road_segment_point)):\n id = road_segment_point[i]['shapeid']\n rpoint.append({'id': i,\n 'shapeid': id,\n 'point': point,\n 'x': float(road_segment_point[i]['x']),\n 'y': float(road_segment_point[i]['y']),\n 'lowest_cost': float(\"inf\"),\n 'best_server': None,\n 'color_num': GREY})\n if i < len(road_segment_point) - 1:\n id_next = road_segment_point[i + 1]['shapeid']\n if id == id_next:\n point += 1\n else:\n point = 0\n\n # Convert adjacent road segment endpoints to lines (x1, y1) to (x2, y2)\n rseg = []\n line = 0\n seg = 0\n for i in range(len(rpoint[:-1])):\n id = rpoint[i]['shapeid']\n id_next = rpoint[i + 1]['shapeid']\n if id == id_next:\n rseg.append({'id': line,\n 'shapeid': id,\n 'segment': seg,\n 'point1': rpoint[i]['id'],\n 'x1': float(rpoint[i]['x']),\n 'y1': float(rpoint[i]['y']),\n 'point2': rpoint[i + 1]['id'],\n 'x2': float(rpoint[i + 1]['x']),\n 'y2': float(rpoint[i + 1]['y']),\n 'best_server': None,\n 'color_num': GREY})\n line += 1\n seg += 1\n else:\n seg = 0\n\n return snode, rnode, rpoint, rseg","def routes(self) -> List[Tuple[int, bytes]]:\n raise NotImplementedError() # pragma: no cover"],"string":"[\n \"def traverse_graph(F, f, s, t, u, sr):\\n def get_paths_for_flow(F, s, f):\\n \\\"\\\"\\\"\\n RETURNS\\n A set of outgoing links and corresponding splitting ratios for flow f\\n at node s\\n \\\"\\\"\\\"\\n links = [((u, v), split_ratio) \\n for (flow_id, u, v), split_ratio in F.items() \\n if flow_id == f and u == s and split_ratio > 0.001]\\n return links\\n \\n if u == t:\\n return [([t], sr)]\\n\\n outgoing_links = get_paths_for_flow(F, u, f)\\n paths_to_t = []\\n\\n for ((current_node, next_hop), split_ratio) in outgoing_links:\\n paths_from_u_to_t = traverse_graph(F, f, s, t, next_hop, split_ratio) \\n paths_to_t.extend(paths_from_u_to_t)\\n\\n paths_to_t_with_u = []\\n for path in paths_to_t:\\n nodes, sr = path\\n new_path = [u] + nodes\\n paths_to_t_with_u.append((new_path, sr))\\n\\n return paths_to_t_with_u\",\n \"def step(nodes, outputs, edges):\\n flowed = []\\n for node_name in nodes.copy():\\n if node_name in flowed:\\n continue\\n if len(nodes[node_name]) == 2:\\n if node_name in flowed:\\n continue\\n node = [int(value) for value in nodes[node_name]]\\n low_value, high_value = min(node), max(node)\\n low_flow, high_flow = edges[node_name] \\n low_dictionary, low_node_name = low_flow\\n high_dictionary, high_node_name = high_flow\\n low_node = low_dictionary.get(low_node_name, tuple())\\n high_node = high_dictionary.get(high_node_name, tuple())\\n low_dictionary[low_node_name] = low_node + (str(low_value),)\\n high_dictionary[high_node_name] = high_node + (str(high_value),)\\n nodes[node_name] = tuple()\\n if low_dictionary is nodes:\\n flowed.append(low_node_name)\\n if high_dictionary is nodes:\\n flowed.append(high_node_name)\\n return nodes, outputs, edges\",\n \"def split_at_nodes(shp):\\n nodes = find_nodes(shp)\\n nodeIds = list(nodes)\\n nodeIds.sort()\\n nodeIds = dict([(node,i) for i,node in enumerate(nodeIds)])\\n \\n for road in shp:\\n vrts = road.vertices\\n midVrts = set(road.vertices[1:-1]) #we know end points are nodes\\n midNodes = midVrts.intersection(nodes) # find any nodes in the middle of the feature.\\n midIdx = [vrts.index(node) for node in midNodes] # Get their indices\\n midIdx.sort()\\n if midIdx:\\n #print vrts\\n starts = [0]+midIdx\\n stops = [x+1 for x in midIdx]+[None]\\n for start,stop in zip(starts,stops):\\n feat = pysal.cg.Chain(vrts[start:stop])\\n rec = (nodeIds[feat.vertices[0]],nodeIds[feat.vertices[-1]],False)\\n yield feat,rec\\n else:\\n rec = (nodeIds[road.vertices[0]],nodeIds[road.vertices[-1]],False)\\n yield road,rec\",\n \"def _split(self):\\r\\n \\r\\n temp = [self.upstream.demand]\\r\\n for item, p in zip(self.downstream, self.priority):\\r\\n temp.append(item.supply/p)\\r\\n \\r\\n flow = min(temp) # total flow\\r\\n \\r\\n self.upstream.outflow = flow\\r\\n \\r\\n for item, p in zip(self.downstream, self.priority):\\r\\n item.inflow = p * flow\",\n \"def ford_fulkerson_algorithm(graph: np.ndarray, source: int, sink: int) -> np.ndarray:\\r\\n\\r\\n residual_graph = copy.deepcopy(graph)\\r\\n row = len(residual_graph)\\r\\n parent = [-1] * row\\r\\n max_flow = 0\\r\\n\\r\\n if source == sink or sink < 0 or source < 0 or source >= row or sink >= row:\\r\\n raise WrongInputException('Wrong input source/sink vertice(s)')\\r\\n\\r\\n while bfs(residual_graph, row, source, sink, parent):\\r\\n\\r\\n path_flow = float(\\\"Inf\\\")\\r\\n s = sink\\r\\n while s != source:\\r\\n path_flow = min(path_flow, residual_graph[parent[s]][s])\\r\\n s = parent[s]\\r\\n\\r\\n max_flow += path_flow\\r\\n\\r\\n v = sink\\r\\n while v != source:\\r\\n u = parent[v]\\r\\n residual_graph[u][v] -= path_flow\\r\\n residual_graph[v][u] += path_flow\\r\\n v = parent[v]\\r\\n print(\\\"Max flow: %d\\\" % max_flow)\\r\\n\\r\\n return residual_graph\",\n \"def split_edges(self, maximum_distance):\\n \\\"\\\"\\\" Iterate through the vertices of each section. For each vertex v, evaluate edges for which v is a source.\\n If an edge of weight greater than maximum_distance, then split it. \\\"\\\"\\\"\\n for section_id in self.sections:\\n utils.print_progress(len(self.sections), prefix='splitting edges')\\n current_section = [] # Need to update the section data after splitting the edges.\\n for source in self.sections[section_id]:\\n current_section.append(source)\\n edges_to_remove = [] # If an edge is split, it will need to be removed.\\n for edge in self.graph.get_out_edges(source):\\n if self.edge_weights[edge] > maximum_distance:\\n target = edge[1] # edge is a numpy array of [source, target, edge]. Select target.\\n edges_to_remove.append(self.graph.edge(edge[0], edge[\\n 1])) # If an edge is split, the original edge should be removed.\\n\\n new_edge_count = int(math.ceil(self.edge_weights[edge] / maximum_distance))\\n new_edge_distance = self.edge_weights[edge] / new_edge_count\\n current_point = shapes.Point.from_list(\\n list(self.node_locations[source]) + [self.node_heading[target]])\\n previous_vertex = source\\n for _ in range(new_edge_count):\\n current_point = utils.offset_point(current_point, new_edge_distance, current_point.bearing)\\n current_vertex = self.graph.add_vertex()\\n current_section.append(current_vertex) # The new vertex becomes a part of the section.\\n \\\"\\\"\\\" Populate the property map for the new vertex. Inherit values from the target node,\\n unless the target node is a junction node. Then inherit values from the source. \\\"\\\"\\\"\\n self.node_locations[current_vertex] = current_point.as_list()\\n self.node_heading[current_vertex] = current_point.bearing\\n property_vertex = source if not self.junctions[target] else target\\n self.node_speed_limit[current_vertex] = self.node_speed_limit[property_vertex]\\n self.node_width[current_vertex] = self.node_width[property_vertex]\\n self.node_id[current_vertex] = self.node_id[property_vertex]\\n\\n \\\"\\\"\\\" Create an edge between the previous vertex and the newly created vertex, \\n and update the edge weight property map. \\\"\\\"\\\"\\n current_edge = self.graph.add_edge(previous_vertex, current_vertex)\\n self.edge_weights[current_edge] = new_edge_distance\\n\\n # The current vertex becomes the previous vertex in the next step.\\n previous_vertex = current_vertex\\n\\n \\\"\\\"\\\" Create an edge between the last new vertex that was created and the target of the\\n original edge which is being split, and update the property map. \\\"\\\"\\\"\\n self.edge_weights[self.graph.add_edge(previous_vertex, target)] = new_edge_distance\\n list(map(self.graph.remove_edge, edges_to_remove)) # Remove all relevant edges\\n self.sections[section_id] = current_section # Update the section with the new vertices\",\n \"def dfs(x, p, step):\\n disc[x] = low[x] = step\\n for xx in graph.get(x, []): \\n if disc[xx] == inf: \\n step += 1\\n dfs(xx, x, step)\\n low[x] = min(low[x], low[xx])\\n if low[xx] > disc[x]: ans.append([x, xx]) # bridge\\n elif xx != p: low[x] = min(low[x], disc[xx])\",\n \"def get_flow_2frames(self, x):\\n b, n, c, h, w = x.size()\\n x_1 = x[:, :-1, :, :, :].reshape(-1, c, h, w)\\n x_2 = x[:, 1:, :, :, :].reshape(-1, c, h, w)\\n flows_backward = self.spynet(x_1, x_2)\\n flows_backward = [flow.view(b, n - 1, 2, h // 2 ** i, w // 2 ** i) for flow, i in zip(flows_backward, range(4))]\\n flows_forward = self.spynet(x_2, x_1)\\n flows_forward = [flow.view(b, n - 1, 2, h // 2 ** i, w // 2 ** i) for flow, i in zip(flows_forward, range(4))]\\n return flows_backward, flows_forward\",\n \"def sg_hops (self):\\n return (link for s, d, link in self.network.edges_iter(data=True) if\\n link.type == Link.SG)\",\n \"def compute_greedy_flow_allocations( target_graph\\n , flow_selection_fn\\n , seed_number=DEFAULT_SEED_NUMBER):\\n\\n flow_allocation_seed_number = seed_number\\n np.random.seed(flow_allocation_seed_number)\\n\\n link_utilization = {tuple(sorted(link_tuple)): 0.0 for link_tuple in target_graph.edges}\\n flows = []\\n\\n while True:\\n capacity_was_exceeded = False\\n\\n source_node, destination_node = flow_selection_fn(target_graph.nodes)\\n flow_tx_rate = np.random.uniform(FLOW_TX_RATE_LOWER_BOUND, FLOW_TX_RATE_UPPER_BOUND)\\n\\n connecting_paths = list(node_disjoint_paths(target_graph, source_node, destination_node))\\n disjoint_path_count = len(connecting_paths)\\n flow_rate_per_subpath = flow_tx_rate / disjoint_path_count\\n for path in [nx.utils.pairwise(p_i) for p_i in connecting_paths]:\\n for u, v in [tuple(sorted(t_i)) for t_i in path]:\\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\\n capacity_was_exceeded = True\\n break\\n link_utilization[u, v] += flow_rate_per_subpath\\n if capacity_was_exceeded:\\n break\\n if capacity_was_exceeded:\\n break\\n\\n the_flow = Flow( source_node = source_node\\n , destination_node = destination_node\\n , flow_tx_rate = flow_tx_rate\\n , paths = connecting_paths\\n , splitting_ratio = [1.0/disjoint_path_count]*disjoint_path_count\\n )\\n flows.append(the_flow)\\n return flows, link_utilization\",\n \"def compute_flow(self, lqs):\\n n, t, c, h, w = lqs.size()\\n lqs_1 = lqs[:, :-1, :, :, :].reshape(-1, c, h, w)\\n lqs_2 = lqs[:, 1:, :, :, :].reshape(-1, c, h, w)\\n flows_backward = self.spynet(lqs_1, lqs_2).view(n, t - 1, 2, h, w)\\n if self.is_mirror_extended:\\n flows_forward = None\\n else:\\n flows_forward = self.spynet(lqs_2, lqs_1).view(n, t - 1, 2, h, w)\\n return flows_forward, flows_backward\",\n \"def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\\n demand: float,\\n routing: np.ndarray) -> np.ndarray:\\n edge_mapping = {edge: i for i, edge in\\n enumerate(sorted(self.graph.edges))}\\n\\n link_utilisation = np.zeros(self.num_edges)\\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\\n node_flow[flow[0]] = demand\\n\\n to_explore = [flow[0]]\\n while to_explore:\\n current_node = to_explore.pop(0)\\n current_flow = node_flow[current_node]\\n\\n # this is the flow destination node so we absorb all flow\\n if current_node == flow[1]:\\n node_flow[current_node] = 0.0\\n continue\\n\\n # push the flow at this node over all edges\\n for edge in self.graph.out_edges(current_node):\\n edge_index = edge_mapping[edge]\\n ratio = routing[edge_index]\\n flow_to_send = ratio * current_flow\\n # only send flow if greater than epsilon (so no 'infinite' loops)\\n if flow_to_send > 1.e-8:\\n node_flow[edge[1]] += ratio * current_flow\\n # all important step, update our output\\n link_utilisation[edge_index] += ratio * current_flow\\n # have updated the dst so add it to the list of things to do\\n to_explore.append(edge[1])\\n # we've moved all the flow from this node now, so reset back to zero\\n node_flow[current_node] = 0.0\\n\\n return link_utilisation\",\n \"def DRBFS(self, flow, edge_mark):\\n\\t\\t# Distance flag for each node\\n\\t\\td = {v:float('inf') for v in self.topo.nodes}\\n\\t\\t# Parent node for each node\\n\\t\\tpa = {v:-1 for v in self.topo.nodes}\\n\\t\\t# Request info\\n\\t\\ts = flow[0]\\n\\t\\tt = flow[1]\\n\\n\\t\\t# BFS to find a min-hop path\\n\\t\\tqueue = [s]; hdr = 0; d[s] = 0\\n\\t\\twhile hdr < len(queue):\\n\\t\\t\\tu = queue[hdr]\\n\\t\\t\\thdr += 1\\n\\n\\t\\t\\tfor v in self.topo.topo.neighbors(u):\\n\\t\\t\\t\\tif edge_mark[(u, v)] or d[v] <= d[u] + 1:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tqueue.append(v)\\n\\t\\t\\t\\td[v] = d[u] + 1\\n\\t\\t\\t\\tpa[v] = u\\n\\t\\t\\t\\tif v == t:\\n\\t\\t\\t\\t\\t# This is because when BFS on edges, the first time reaching t meaning the smallest hop it can be reached\\n\\t\\t\\t\\t\\thdr = len(queue)\\n\\t\\t\\t\\t\\tbreak\\n\\n\\t\\tif d[t] == float('inf'):\\n\\t\\t\\treturn False\\n\\n\\t\\tp = [t]; v = t\\n\\t\\twhile v != s and v != -1:\\n\\t\\t\\tv = pa[v]\\n\\t\\t\\tp.append(v)\\n\\t\\tp.reverse()\\n\\n\\t\\treturn p\",\n \"def get_all_sghop_info (nffg, return_paths=False):\\n sg_map = {}\\n for i in nffg.infras:\\n for p in i.ports:\\n for fr in p.flowrules:\\n # if fr.external:\\n # continue\\n if fr.id not in sg_map:\\n # The path is unordered!!\\n path_of_shop = []\\n flowclass = NFFGToolBox._extract_flowclass(fr.match.split(\\\";\\\"))\\n sg_map[fr.id] = [None, None, flowclass, fr.bandwidth, fr.delay]\\n # We have to find the BEGINNING of this flowrule sequence.\\n inbound_link = NFFGToolBox._find_infra_link(nffg, p, outbound=False,\\n accept_dyn=True)\\n while inbound_link.type != 'DYNAMIC':\\n path_of_shop.append(inbound_link)\\n if inbound_link.src.node.type == 'SAP':\\n break\\n # The link is STATIC, and its src is not SAP so it is an Infra.\\n prev_fr, prev_p = \\\\\\n NFFGToolBox._get_flowrule_and_its_starting_port(\\n inbound_link.src.node, fr.id)\\n NFFGToolBox._check_flow_consistencity(sg_map, prev_fr)\\n inbound_link = NFFGToolBox._find_infra_link(nffg, prev_p,\\n outbound=False,\\n accept_dyn=True)\\n # 'inbound_link' is DYNAMIC here or it is STATIC and starts from\\n # a SAP,\\n # so the sequence starts here\\n sg_map[fr.id][0] = inbound_link.src\\n\\n # We have to find the ENDING of this flowrule sequence.\\n output_port = NFFGToolBox._get_output_port_of_flowrule(i, fr)\\n if output_port is None:\\n continue\\n outbound_link = NFFGToolBox._find_infra_link(nffg, output_port,\\n outbound=True,\\n accept_dyn=True)\\n while outbound_link.type != 'DYNAMIC':\\n path_of_shop.append(outbound_link)\\n if outbound_link.dst.node.type == 'SAP':\\n break\\n # The link is STATIC and its dst is not a SAP so it is an Infra.\\n next_fr, _ = NFFGToolBox._get_flowrule_and_its_starting_port(\\n outbound_link.dst.node, fr.id)\\n # '_' is 'outbound_link.dst'\\n next_output_port = NFFGToolBox._get_output_port_of_flowrule(\\n outbound_link.dst.node, next_fr)\\n NFFGToolBox._check_flow_consistencity(sg_map, next_fr)\\n outbound_link = NFFGToolBox._find_infra_link(nffg,\\n next_output_port,\\n outbound=True,\\n accept_dyn=True)\\n # the 'outbound_link' is DYNAMIC here or finishes in a SAP, so the\\n # flowrule sequence finished here.\\n sg_map[fr.id][1] = outbound_link.dst\\n\\n if return_paths:\\n sg_map[fr.id].append(path_of_shop)\\n\\n return sg_map\",\n \"def routes_for_od(self, r, s):\\n\\n for path in self.paths_for_od(r, s):\\n route = self._road_network.network.copy()\\n\\n for edge in route.edges_iter():\\n u,v = edge\\n if BaseRouter._edge_in_path(path, edge):\\n route.edge[u][v]['pathweight'] = 0.1\\n else:\\n route.edge[u][v]['pathweight'] = 1.0\\n\\n # Set node weights\\n for node in route:\\n try:\\n dist_from_path = nx.shortest_path_length(route,\\n node,\\n path[-1],\\n weight='pathweight')\\n except nx.NetworkXNoPath:\\n dist_from_path = float('inf')\\n\\n route.node[node]['weight'] = math.exp(-self._beta*dist_from_path)\\n\\n \\n # Create policy from weights\\n def edge_weight(u,v):\\n return route.node[v]['weight']*math.exp(\\n -self._beta*route.edge[u][v]['pathweight'])\\n\\n for node in route:\\n edges = route.edges(node)\\n total_edge_weight = reduce(\\n lambda x,y: x+y,\\n [edge_weight(u,v) for u,v in edges],\\n 0.0)\\n\\n for u,v in edges:\\n route[u][v]['weight'] = \\\\\\n edge_weight(u, v) / float(total_edge_weight)\\n\\n yield Route(route, path)\",\n \"def dfs_r(self, s):\\n g = Graph(attr={DIRECTED: True})\\n return self.dfs_rec(g, ('#', s))\",\n \"def distribute(node, rank_links):\\n r = rank_links[0]\\n links = rank_links[1]\\n\\n ol = str(links).split('|')\\n Ni = len(ol)\\n\\n # if the node is for dangling (i.e. no outgoing link),\\n # emit the loss to redistribute to all the incoming\\n # links to the dangling node\\n if (Ni == 1 and ol[0] == '') or Ni == 0:\\n yield 'DANGLING', r\\n else:\\n r_new = float(r)/float(Ni)\\n for l in ol:\\n yield l, r_new\\n\\n # recover graph structure\\n if links <> '':\\n yield node, links\",\n \"def update_flow(self):\\n start_nodes = []\\n end_nodes = []\\n capacities = []\\n # (1): add all edges (u, v) with capacity ub-lb\\n B = self.get_max_lb()*(self.num_edges() - len(self) + 2)\\n for arc in self.arc_info.keys():\\n if self.arc_info[arc][\\\"upper_bound\\\"] == float('inf'):\\n self.arc_info[arc][\\\"upper_bound\\\"] = B\\n for arc in self.arc_info.keys():\\n start_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n capacities.append(int(self.arc_info[arc][\\\"upper_bound\\\"]\\\\\\n - self.arc_info[arc][\\\"lower_bound\\\"]))\\n # (2): add edge (t, s) with capacity B\\n # B = max_lb * (m - n + 2)\\n B = self.get_max_lb()*(self.num_edges() - len(self) + 2)\\n if B == 0:\\n #B = float('inf')\\n B = 100000\\n start_nodes.append(self.sink())\\n end_nodes.append(self.source())\\n capacities.append(int(B))\\n # (3): for all verts, if exc > 0, add edge (s', v) with capacity exc(v),\\n # and if exc < 0, add edge(s', v) with capacity -exc(v)\\n s_prime = max(self.vertices) + 1\\n t_prime = max(self.vertices) + 2\\n print(\\\"s'={}, t'={}\\\".format(s_prime, t_prime))\\n for v in self:\\n #print(\\\"vert {} in arcs: {}\\\".format(v,\\n # self.in_arcs_lists[v]))\\n # compute exc: lower bounds of in - lower bounds of out\\n sum_lb_in = 0\\n for in_arc in self.in_arcs_lists[v]:\\n sum_lb_in += self.arc_info[in_arc][\\\"lower_bound\\\"]\\n sum_lb_out = 0\\n #print(\\\"vert {} out arcs: {}\\\".format(v,\\n # self.out_arcs_lists[v]))\\n for out_arc in self.out_arcs_lists[v]:\\n sum_lb_out += self.arc_info[out_arc][\\\"lower_bound\\\"]\\n exc = sum_lb_in - sum_lb_out\\n #print(\\\"exc is {}\\\".format(exc))\\n if exc > 0:\\n start_nodes.append(s_prime)\\n end_nodes.append(v)\\n capacities.append(int(exc))\\n else:\\n start_nodes.append(v)\\n end_nodes.append(t_prime)\\n capacities.append(int(-exc))\\n # solve maxflow\\n #print(\\\"s' is {} and t' is {}\\\".format(s_prime, t_prime))\\n max_flow = pywrapgraph.SimpleMaxFlow()\\n for u, v, cap in zip(start_nodes, end_nodes, capacities):\\n #print(\\\"Adding edge {}, {} with cap {}\\\".format(u,v,cap))\\n max_flow.AddArcWithCapacity(u, v, cap)\\n success = True\\n if max_flow.Solve(s_prime, t_prime) == max_flow.OPTIMAL:\\n #print('Max flow: {}'.format( max_flow.OptimalFlow()))\\n #print(' Arc Flow / Capacity')\\n for i in range(max_flow.NumArcs()):\\n # print('%1s -> %1s %3s / %3s' % (\\n # max_flow.Tail(i),\\n # max_flow.Head(i),\\n # max_flow.Flow(i),\\n # max_flow.Capacity(i)))\\n # check that (s', v) edges are saturated (once we find a false,\\n # stay false forever)\\n if success:\\n if max_flow.Tail(i) == s_prime:\\n success = max_flow.Flow(i) == max_flow.Capacity(i)\\n else:\\n success = False\\n print('There was an issue with the max flow input.')\\n if success:\\n # update the flows to be the flow found from maxflow problem\\n for i in range(max_flow.NumArcs()):\\n # if this is an original arc, update the flow\\n if max_flow.Tail(i) != s_prime \\\\\\n and max_flow.Head(i) != t_prime \\\\\\n and not (max_flow.Tail(i) == self.sink() \\\\\\n and max_flow.Head(i) == self.source()):\\n # update arc\\n start = max_flow.Tail(i)\\n destin = max_flow.Head(i)\\n arc = self.get_arc(start, destin)\\n new_flow = self.arc_info[arc][\\\"lower_bound\\\"] + max_flow.Flow(i)\\n old_flow = self.arc_info[arc][\\\"weight\\\"]\\n self.arc_info[arc][\\\"weight\\\"] = new_flow\\n #print(\\\"Edge {} {} adjusted from {} to {}\\\".format(\\n # start,\\n # destin,\\n # old_flow,\\n # new_flow\\n # ))\\n self.check_conservation_of_flow() # check that solution is valid\\n return True\\n else:\\n return False\",\n \"def findPathsToBase(A,bSize):\\n M,N = A.shape\\n pressedPaths = []\\n\\n #For every two nodes in the base find all paths between them\\n for b1 in range(bSize):\\n for b2 in range(bSize):\\n #Remove all other base nodes from the graph so that\\n #we only find paths that go through the specialization set\\n if b1 == b2:\\n #In this case we are looking for a cycle.\\n mask = [b1]+list(range(bSize,N))\\n newSize = len(mask) + 1\\n reduA = np.zeros((newSize,newSize))\\n #Because the networkx cycle finders don't do what we need\\n #them to do, we create a new graph and find paths instead\\n reduA[:-1,:-1] = A[mask,:][:,mask]\\n #Remove ingoing edges from the base node and add to new node\\n reduA[-1,:] = reduA[0,:]\\n reduA[0,:] = np.zeros(newSize)\\n G = nx.DiGraph(reduA.T)\\n #Find paths from the base node to the new node\\n #same as finding all the cycles\\n paths = list(nx.all_simple_paths(G,0,newSize-1))\\n\\n else:\\n mask = [b1,b2]+list(range(bSize,N))\\n reduA = A[mask,:][:,mask]\\n #Remove base node interactions\\n reduA[:2,:2] = np.zeros((2,2))\\n G = nx.DiGraph(reduA.T)\\n paths = list(nx.all_simple_paths(G,0,1))\\n\\n #Process Paths so that they make sense when the rest of the base\\n #set is added to the graph\\n for p in paths:\\n if p != []:\\n if b1 == b2:\\n p = np.array(p) + bSize-1\\n else:\\n p = np.array(p) + bSize-2\\n p[[0,-1]] = [b1, b2]\\n pressedPaths.append(p)\\n\\n return pressedPaths\",\n \"def compute_half_life_vested_shares(params, step, sL, s, inputs):\\n key = 'delegators'\\n \\n delegators = s['delegators']\\n\\n half_life_vesting_rate = params['half_life_vesting_rate']\\n \\n for delegator in delegators.values():\\n # for future computation speed, vest them in chunks, it doesn't matter which chunk\\n shares_vesting_this_period = delegator.unvested_shares * half_life_vesting_rate\\n for timestep in delegator._unvested_shares:\\n remaining_shares_to_vest = shares_vesting_this_period\\n if delegator._unvested_shares[timestep] > remaining_shares_to_vest:\\n delegator._unvested_shares[timestep] -= remaining_shares_to_vest\\n break\\n else:\\n # 0 out and go onto the next one\\n remaining_shares_to_vest -= delegator._unvested_shares[timestep]\\n delegator._unvested_shares[timestep] = 0\\n \\n delegator.vested_shares += shares_vesting_this_period\\n # print(f'{delegator.vested_shares=}, {delegator.unvested_shares=}, {delegator.shares=}')\\n value = delegators\\n\\n return key, value\",\n \"def dfs_traversal(graph, s, goals=[]):\\n visited = []\\n boundary = [s]\\n while len(boundary) > 0:\\n v = boundary.pop()\\n visited += [v]\\n if v in goals:\\n return visited\\n for w in neighbours(v, graph):\\n if w not in visited and w not in boundary:\\n boundary.append(w)\\n return visited\\n\\n \\\"\\\"\\\"\\n visited = []\\n boundary = [s]\\n while len(boundary) > 0:\\n v = boundary.pop()\\n visited += [v]\\n for w in neighbours(v, graph):\\n if w not in visited and w not in boundary:\\n boundary.append(w)\\n if w in goals:\\n v = boundary.pop()\\n visited += [v]\\n return visited\\n\\\"\\\"\\\"\",\n \"def get_dfs(self, s):\\n results = []\\n # mark all the vertices as not visited\\n visited = [False] * (len(self.graph))\\n self._dfs_recursive(s, visited, results)\\n return results\",\n \"def bfs(g: nx.Graph, start_node: Hashable) -> List[Hashable]:\\n list_ = list(g.neighbors(start_node))\\n len_graph = g.number_of_nodes()\\n list2 = [start_node]\\n while len(list2) < len_graph:\\n for i in range(len(list_) - 1):\\n if list_[0] not in list2:\\n list2.append(list_[0])\\n list_ += list(g.neighbors(list_[0]))\\n list_.remove(list_[0])\\n # nx.draw(g, with_labels=True)\\n # plt.show()\\n return list2\",\n \"def flowingFrom(self, fount):\",\n \"def hmn2(a, s, m0):\\n n = 2*m0**s\\n links = np.zeros((int(a/m0*n*sum([1/2**x for x in range(1, s+1)])), 2), dtype=np.int32)\\n links_i = 0\\n p = 0\\n \\n # At each hierarchy level a number of a links are established,\\n # repeating the process if links are repeated.\\n for si in range(1, s+1):\\n m0_si = m0**si\\n for n in range(0, n+1-2*m0_si, 2*m0_si):\\n \\n if a == 1:\\n i = np.random.randint(0 + n, m0_si + n)\\n j = np.random.randint(m0_si + n, 2*m0_si + n)\\n links[p] = np.array([i, j])\\n p += 1\\n \\n else:\\n while len(np.unique(links[links_i:a + links_i], axis=0)) != a:\\n for m in range(a):\\n i = np.random.randint(0 + n, m0_si + n)\\n j = np.random.randint(m0_si + n, 2*m0_si + n)\\n links[links_i:a + links_i][m] = np.array([i, j])\\n links_i += a\\n \\n blocks = np.arange(n).reshape((int(n/m0), m0))\\n return np.concatenate((blocks, links))\",\n \"def destination_floors(self):\\r\\n return self.destinations\",\n \"def compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\\n logger.debug(f\\\"comparing {node1},{node2}, traversed {traversed}\\\")\\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\\n #remove dummies\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\\n #remove dummies\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\\n logger.debug(f\\\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\\\")\\n logger.debug(f\\\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\\\")\\n if not nbrs1 or not nbrs2:\\n if compare_two_nodes(G, node1, node2, ports_weight):\\n match_pair[node1] = node2\\n logger.debug(f\\\"no new neihbours, returning recursion {match_pair}\\\")\\n return\\n elif len(nbrs1)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node1} {nbrs1}\\\")\\n traversed.append(node1)\\n return\\n elif len(nbrs2)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n traversed.append(node2)\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node2} {nbrs2}\\\")\\n return\\n\\n if node1 == node2:\\n if node1 in match_pair.keys() or node1 in match_pair.values():\\n logger.debug(\\\"avoid existing pair wise symmetry\\\")\\n return\\n logger.debug(f\\\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\\\")\\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\\n ## TBD: filter based on primitive constraints\\n ## Right now will try to figure out S/D paths\\n if len(SD_nbrs) ==0:\\n logger.debug(f\\\"No SD paths found to traverse\\\")\\n match_pair[node1]=node1\\n elif len(SD_nbrs) ==1:\\n logger.debug(f\\\"traversing single S/D path {SD_nbrs}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\\n else:\\n logger.debug(f\\\" multiple nodes diverging {SD_nbrs}\\\")\\n logger.debug(f\\\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n new_sp=sorted(set(SD_nbrs)-set(traversed))\\n all_match_pairs_local={}\\n for nbr1,nbr2 in combinations(new_sp, 2):\\n logger.debug(f\\\"recursive pair call from single branch {nbr1} {nbr2}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n if new_pair:\\n #new_pair[nbr1]=nbr2\\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\\n if len(all_match_pairs_local)==1:\\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\\n logger.debug(f\\\"found inline pair: {pprint.pformat(match_pair, indent=4)}\\\")\\n else:\\n for nbr1 in new_sp:\\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\\n logger.debug(f\\\"recursive single branch call from single branch {nbr1} {nbr1}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif nbrs1 == nbrs2:\\n logger.debug(f\\\"traversing converging branch\\\")\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\\n logger.debug(f\\\"all non traversed neighbours: {nbrs1}\\\")\\n if len(nbrs1)==1:\\n nbr1=nbr2=nbrs1[0]\\n logger.debug(f\\\"keeping single converged branch inline {nbr1} {nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n else:\\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\\n logger.debug(f\\\"recursive call from converged branch {nbr1} {nbr2}\\\")\\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif compare_two_nodes(G,node1,node2,ports_weight):\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n logger.debug(f\\\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\\\")\\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\\n if len(nbrs1)==0 or len(nbrs2)==0:\\n logger.debug(f\\\"no new SD neihbours, returning recursion {match_pair}\\\")\\n elif len(nbrs1) ==1 and len(nbrs2)==1:\\n logger.debug(f\\\"traversing binary branch\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\\n elif unique_match:\\n logger.debug(f'traversing unique matches {unique_match}')\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n for nbr1,nbr2 in unique_match.items():\\n logger.debug(f\\\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\\n logger.debug(f\\\"setting new start points {node1} {node2}\\\")\\n match_pair[node1]=node2\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end all traversal from binary branch {node1} {node2}\\\")\\n\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end of recursion branch, matches {match_pair}\\\")\",\n \"def enumerate_links_around_node(self, node):\\n\\n l0 = self.node_link[node]\\n l = l0\\n edges = []\\n traversing = True\\n while traversing:\\n edges.append(l)\\n v = l[0]\\n if v == node:\\n l = self.pred_right[l]\\n else:\\n l = self.pred_left[l]\\n if l0 == l:\\n traversing = False\\n if l0[1] == l[0] and l0[0] == l[1]:\\n traversing = False\\n #print v, l\\n #raw_input('here')\\n return edges\",\n \"def directed_dfs(digraph, start, end, max_total_dist, max_dist_outdoors):\\n\\n\\n path = [[],0 , 0]\\n best_path = get_best_path(digraph, start, end, path, max_dist_outdoors, max_total_dist, best_path = None)\\n\\n if best_path[0] is None:\\n raise ValueError('No work')\\n else :\\n return best_path[0]\",\n \"def conversion(data_path, nodes, simtime, resolution=1):\\r\\n\\r\\n receivers = set() # i.e. neurons; senders can be external inputs\\r\\n edges_set = set()\\r\\n\\r\\n # Ask number of neurons per node\\r\\n nodes_dict = dict()\\r\\n if input(\\\"Every node has same number of neurons? (y/n)\\\") == \\\"y\\\":\\r\\n n = int(input(\\\"Number of neurons per node: \\\"))\\r\\n for node in range(nodes):\\r\\n nodes_dict[node] = n\\r\\n receivers.update([str(node) + \\\"-\\\" + str(neuron) for neuron in range(nodes_dict[node])])\\r\\n else:\\r\\n for node in range(nodes):\\r\\n nodes_dict[node] = int(input(\\\"Number of neurons in node %s: \\\" % node))\\r\\n receivers.update([str(node) + \\\"-\\\" + str(neuron) for neuron in range(nodes_dict[node])])\\r\\n\\r\\n receivers = sorted(list(receivers))\\r\\n\\r\\n # Load a part of FNS data to gather information about edges\\r\\n df = pd.read_csv(data_path, header=None, usecols=[0, 1, 2, 3, 4, 5], chunksize=500000, nrows=2000000)\\r\\n for chunk in df:\\r\\n chunk.columns = [\\\"Burning Time\\\", \\\"Firing Node\\\", \\\"Firing Neuron\\\", \\\"Burning Node\\\", \\\"Burning Neuron\\\",\\r\\n \\\"External Source\\\"]\\r\\n print(chunk.index)\\r\\n for node in range(nodes):\\r\\n temp = chunk.loc[\\r\\n (chunk[\\\"Burning Node\\\"] == node) & (chunk[\\\"External Source\\\"] == False)] # Remove external inputs\\r\\n for i in range(len(temp)):\\r\\n print(\\\"Gathering edge information for node: %i/%i. Connection: %i/%i\\\" % (\\r\\n node + 1, nodes, i + 1, len(temp)), end=\\\"\\\\r\\\")\\r\\n sender = str(np.asarray(temp[\\\"Firing Node\\\"])[i]) + \\\"-\\\" + str(np.asarray(temp[\\\"Firing Neuron\\\"])[i])\\r\\n receiver = str(node) + \\\"-\\\" + str(np.asarray(temp[\\\"Burning Neuron\\\"])[i])\\r\\n edges_set.add((sender, receiver))\\r\\n print(\\\"Gathering edge information for node: %i/%i. Connection: %i/%i\\\" % (node + 1, nodes, i + 1, len(temp)))\\r\\n\\r\\n status_table = pd.DataFrame(np.zeros((len(receivers), len(range((simtime - 1) * resolution)))),\\r\\n columns=list(range((simtime - 1) * resolution)), index=receivers)\\r\\n\\r\\n df = pd.read_csv(data_path, header=None, usecols=[0, 1, 2, 3, 4, 5], chunksize=1000000)\\r\\n for chunk in df:\\r\\n chunk.columns = [\\\"Burning Time\\\", \\\"Firing Node\\\", \\\"Firing Neuron\\\", \\\"Burning Node\\\", \\\"Burning Neuron\\\",\\r\\n \\\"External Source\\\"]\\r\\n print(chunk.index)\\r\\n\\r\\n # Loop over times instead of receivers: slightly better efficiency for large datasets\\r\\n times_raw = sorted(set(chunk[\\\"Burning Time\\\"]))\\r\\n status_table_temp = pd.DataFrame(columns=receivers)\\r\\n status_table_aux = pd.DataFrame(np.zeros((len(receivers), len(range((simtime - 1) * resolution)))),\\r\\n columns=list(range((simtime - 1) * resolution)), index=receivers)\\r\\n\\r\\n times = list(np.arange(0, int(max(times_raw) + 1), 1 / resolution))\\r\\n min_t = int(np.trunc(min(chunk[\\\"Burning Time\\\"])))\\r\\n max_t = int(np.trunc(max(chunk[\\\"Burning Time\\\"])))\\r\\n\\r\\n for t in times[min_t:max_t]:\\r\\n print(\\\"Gathering nodes' activity dynamics - t: %i/%i\\\" % (t + 1, max_t), end=\\\"\\\\r\\\")\\r\\n temp = chunk.loc[np.trunc(chunk[\\\"Burning Time\\\"]) == t, (\\\"Burning Node\\\", \\\"Burning Neuron\\\")]\\r\\n # Count burning events for each neuron at time t\\r\\n count = Counter([str(node) + \\\"-\\\" + str(neuron) for node, neuron in np.asarray(temp)])\\r\\n # Every time step we add a Counter dict to fill status table\\r\\n status_table_temp = status_table_temp.append(count, ignore_index=True)\\r\\n print(\\\"Gathering nodes' activity dynamics - t: %i/%i\\\" % (t + 1, max_t))\\r\\n\\r\\n # status_table_temp contains just a limited space of time each chunk\\r\\n status_table_temp = status_table_temp.transpose()\\r\\n status_table_temp.columns = list(\\r\\n np.arange(start=int(np.trunc(min(chunk[\\\"Burning Time\\\"]))), stop=int(np.trunc(max(chunk[\\\"Burning Time\\\"])))))\\r\\n status_table_temp = status_table_temp.fillna(0)\\r\\n\\r\\n # status_table_aux contains all time steps with temp table values and 0s for the rest each chunk\\r\\n status_table_aux = status_table_aux.add(status_table_temp)\\r\\n status_table_aux = status_table_aux.fillna(0)\\r\\n\\r\\n # status_table merges all chunks' data\\r\\n status_table = status_table.add(status_table_aux)\\r\\n status_table = status_table.fillna(0)\\r\\n\\r\\n timestamp = datetime.now()\\r\\n new_dir = \\\"gephiFiles\\\" + timestamp.strftime(\\\"d%d_%m_%Y-t%H_%M_%S\\\")\\r\\n os.mkdir(new_dir)\\r\\n\\r\\n # Generate gephi compliant files\\r\\n t = \\\"<\\\" + str(times) + \\\">\\\"\\r\\n gephi_nodes = pd.DataFrame(columns=[\\\"id\\\", \\\"label\\\", \\\"timeset\\\", \\\"events\\\", \\\"node\\\"])\\r\\n for idx, node in enumerate(receivers):\\r\\n print(\\\"Writing nodes' file for Gephi: %i/%i\\\" % (idx, len(receivers)), end=\\\"\\\\r\\\")\\r\\n events_row = [[float(i), int(events)] for i, events in enumerate(status_table.loc[node])]\\r\\n events_row = str(events_row).replace(\\\"[[\\\", \\\"<[\\\").replace(\\\"]]\\\", \\\"]>\\\").replace(\\\"],\\\", \\\"];\\\")\\r\\n new_row = pd.Series([node, node, t, events_row, node.split(\\\"-\\\")[0]], index=gephi_nodes.columns)\\r\\n gephi_nodes = gephi_nodes.append(new_row, ignore_index=True)\\r\\n print(\\\"Writing nodes' file for Gephi: %i/%i\\\" % (idx, len(receivers)))\\r\\n gephi_nodes.to_csv(new_dir + \\\"/gephi_nodes.csv\\\", index=False)\\r\\n\\r\\n print(\\\"Compute gephi files with %i edges will last %0.2fm approx.\\\" % (len(edges_set), len(edges_set) / 12000))\\r\\n if input(\\\"Do you want to proceed? (y/n) \\\") == \\\"n\\\":\\r\\n exit()\\r\\n gephi_edges = pd.DataFrame(columns=[\\\"Source\\\", \\\"Target\\\", \\\"type\\\", \\\"id\\\", \\\"weight\\\"])\\r\\n for idx, edge in enumerate(edges_set):\\r\\n print(\\\"Writing edges' file for Gephi: %i/%i\\\" % (idx, len(edges_set)), end=\\\"\\\\r\\\")\\r\\n edge_row = pd.Series([edge[0], edge[1], \\\"Directed\\\", idx, 1], index=gephi_edges.columns)\\r\\n gephi_edges = gephi_edges.append(edge_row, ignore_index=True)\\r\\n print(\\\"Writing edges' file for Gephi: %i/%i\\\" % (idx, len(edges_set)))\\r\\n gephi_edges.to_csv(new_dir + \\\"/gephi_edges.csv\\\", index=False)\\r\\n\\r\\n return None\",\n \"def ssf(n, N_max = 6, E_max = 4, time_total = 100 ):\\n\\n G = nx.DiGraph()\\n G.add_edge( 0, 1, time_stamp = 1)\\n\\n # List of existing nodes, with nodes repeated once for each adjacent edge\\n repeated_nodes = [0, 1]\\n\\n # compute discrete bins for nodes \\n DistNodes = _get_distribution( N_max, 0 )\\n # compute discrete bins for edges\\n DistLinks = _get_distribution( E_max, 1 )\\n \\n # Start adding the other n - 2 nodes.\\n N_current = time_current = 2\\n while N_current < n and time_current < time_total + 1:\\n # preferential attachment\\n N_current = _preferential_attachment( DistNodes, DistLinks, N_current,\\n time_total, time_current, n, repeated_nodes, G )\\n time_current += 1\\n \\n# print(time_current, N_current)\\n return G\",\n \"def calc_overall_link_utilisation(self, demands: Demand,\\n routing: Routing) -> np.ndarray:\\n flows = [(i, j) for i in range(self.num_nodes)\\n for j in range(self.num_nodes)\\n if i != j]\\n\\n link_utilisation = np.zeros(self.num_edges)\\n\\n for i, flow in enumerate(flows):\\n flow_link_utilisation = self.calc_per_flow_link_utilisation(flow,\\n demands[\\n i],\\n routing[\\n i])\\n link_utilisation += flow_link_utilisation\\n\\n return link_utilisation\",\n \"def hmn1(a, p, s, m0):\\n n = 2*m0**s\\n links = np.zeros((2*int(a/m0*n*sum([1/2**x for x in range(1, s+1)])), 2), dtype=np.int32)\\n\\n links_i = 0\\n for si in range(1, s+1):\\n # 2 Blocks at the same level get linked with\\n # a shrinking probability with rising level.\\n m0_si = m0**si\\n for n in range(0, n+1-2*m0_si, 2*m0_si):\\n # Connection ensures that at the end of each\\n # linking process, at least one link between\\n # blocks at the same level exists.\\n m0_si_n = m0_si + n\\n connection = 0\\n while connection == 0:\\n for link1 in range(n, m0_si_n):\\n for link2 in range(m0_si_n, 2*m0_si+n): \\n if np.random.rand() < a*p**si:\\n links[links_i] = [link1, link2]\\n links_i += 1\\n connection = 1\\n \\n # Creates the links in the blocks and removes empty\\n # placeholders in links.\\n blocks = np.arange(n).reshape((int(n/m0), m0))\\n links = np.trim_zeros(links.ravel(), 'b').reshape((links_i, 2))\\n\\n return np.concatenate((blocks, links))\",\n \"def get_flows(self, x):\\n if self.pa_frames == 2:\\n flows_backward, flows_forward = self.get_flow_2frames(x)\\n elif self.pa_frames == 4:\\n flows_backward_2frames, flows_forward_2frames = self.get_flow_2frames(x)\\n flows_backward_4frames, flows_forward_4frames = self.get_flow_4frames(flows_forward_2frames, flows_backward_2frames)\\n flows_backward = flows_backward_2frames + flows_backward_4frames\\n flows_forward = flows_forward_2frames + flows_forward_4frames\\n elif self.pa_frames == 6:\\n flows_backward_2frames, flows_forward_2frames = self.get_flow_2frames(x)\\n flows_backward_4frames, flows_forward_4frames = self.get_flow_4frames(flows_forward_2frames, flows_backward_2frames)\\n flows_backward_6frames, flows_forward_6frames = self.get_flow_6frames(flows_forward_2frames, flows_backward_2frames, flows_forward_4frames, flows_backward_4frames)\\n flows_backward = flows_backward_2frames + flows_backward_4frames + flows_backward_6frames\\n flows_forward = flows_forward_2frames + flows_forward_4frames + flows_forward_6frames\\n return flows_backward, flows_forward\",\n \"def BellmanFord(t):\\n\\n\\td = [float('inf') for i in nodes]\\t# Shortest distance to t\\n\\tn = [-1 for i in nodes]\\t\\t\\t# Next hop toward t\\n\\td[t] = 0\\n\\tfor i in range(len(nodes)-1):\\n\\t\\tfor j,(u,v) in enumerate(links):\\n\\t\\t\\tif d[u] > d[v] + length[j]:\\n\\t\\t\\t\\td[u] = d[v] + length[j] \\n\\t\\t\\t\\tn[u] = v\\n\\treturn n,d\",\n \"def get_bipartition(g):\\n # Write your code here.\\n colorArr = [-1] * (len(g.nodes()) + 1)\\n for node in g.nodes():\\n start = g.neighbors(node)\\n if len(start)>0:\\n src = start.pop()\\n break\\n colorArr[src] = 1\\n queue = []\\n queue.append(src)\\n while (queue):\\n u = queue.pop()\\n for v in g.nodes():\\n if g.has_edge(u, v) and colorArr[v] == -1:\\n colorArr[v] = 1 - colorArr[u]\\n queue.append(v)\\n elif g.has_edge(u, v) and colorArr[u] == colorArr[v]:\\n return None\\n\\n red = set()\\n for i in range(1, len(colorArr)):\\n if colorArr[i] == 1:\\n red.add(i)\\n return list(red)\\n\\n\\n\\n # Hint! If you'd like to test out these commands without\\n # writing a full-fledged program, you might want to familiarise\\n # yourself with the Python interactive shell or IPython (available\\n # on at least some Aalto IT computers)\\n\\n # Create a simple line graph g: \\\"(1)->(2)->(3)\\\"\\n # (The creation parameter is a dict of {node: list_of_neighbors},\\n # but this is not something you will be needing in your code.)\\n # >>> from networkx import Graph \\n # >>> g = Graph({1: [2], 2: [3]})\\n # >>> g.number_of_nodes()\\n # 3\\n\\n # Example. Iterate over the nodes and mark them as visited\\n # >>> visited = set()\\n # >>> for node in g.nodes_iter(): # There is also g.nodes(), which returns a list\\n # ... # do some work here\\n # ... visited.add(node)\\n \\n # Example. Given a Node v, get all nodes s.t. there is an edge between\\n # v and that node\\n # >>> g.neighbors(1)\\n # [2]\\n\\n # Example. Get the edges of the graph:\\n # >>> e.edges() # as with nodes, there is also g.edges_iter()\\n # [(1, 2), (2, 3)]\\n\\n # For more information, consult the NetworkX documentation:\\n # https://networkx.github.io/documentation/networkx-1.10/tutorial/tutorial.html\",\n \"def separate_simulations(ns, ps, rs, savename, verbose=True):\\n #TODO: find bug that occasionally does not find the shortest path\\n if verbose:\\n\\n for n, p, r in zip(ns, ps, rs):\\n \\n print('n-{}, p-{}, r-{}'.format(n, p, r))\\n \\n rand_points = np.random.uniform(size=(2, n-2))\\n edge_points = np.array([[0.0, 1.0],[0.0, 1.0]])\\n points = np.concatenate((rand_points, edge_points), axis=1)\\n \\n print('Generated points.', end = '')\\n \\n connections = get_connections(points, pval=p, radius=r)\\n\\n print('Got connections.')\\n \\n print('Getting paths.', end = '...')\\n \\n print('Longest.', end = '...')\\n long_pathBool, long_lengthBool = longest_path(connections.astype(bool))\\n long_path, long_length = longest_path(connections)\\n\\n print('Shortest.', end = '...')\\n short_pathBool, short_lengthBool = shortest_path(connections.astype(bool))\\n short_path, short_length = shortest_path(connections)\\n\\n short_pathBoolpoints, long_pathBoolpoints, short_pathpoints, long_pathpoints = [[list(points[:, u]) for u in indexes] for indexes in [short_pathBool, long_pathBool, short_path, long_path]]\\n\\n print('Saving file -> ' + savename)\\n file1 = open(savename,\\\"a\\\") \\n\\n file1.writelines('{} - {} - {} - {} - {} - {} - {} - {} - {} - {} - {}\\\\n'.format(p, r, n, short_lengthBool, long_lengthBool, short_length, long_length, short_pathBoolpoints, long_pathBoolpoints, short_pathpoints, long_pathpoints))\\n file1.close()\\n \\n else:\\n\\n for n, p, s in zip(ns, ps, rs):\\n\\n rand_points = np.random.uniform(size=(2, n-2))\\n edge_points = np.array([[0.0, 1.0],[0.0, 1.0]])\\n points = np.concatenate((rand_points, edge_points), axis=1)\\n\\n connections = get_connections(points, pval=p, radius=r)\\n\\n long_pathBool, long_lengthBool = longest_path(connections.astype(bool))\\n long_path, long_length = longest_path(connections)\\n\\n short_pathBool, short_lengthBool = shortest_path(connections.astype(bool))\\n short_path, short_length = shortest_path(connections)\\n\\n short_pathBoolpoints, long_pathBoolpoints, short_pathpoints, long_pathpoints = [[list(points[:, u]) for u in indexes] for indexes in [short_pathBool, long_pathBool, short_path, long_path]]\\n\\n file1 = open(savename,\\\"a\\\") \\n\\n file1.writelines('{} - {} - {} - {} - {} - {} - {} - {} - {} - {} - {}\\\\n'.format(p, r, n, short_lengthBool, long_lengthBool, short_length, long_length, short_pathBoolpoints, long_pathBoolpoints, short_pathpoints, long_pathpoints))\\n file1.close()\\n \\n return True\",\n \"def get_path(self, sim, app_name, message, topology_src, alloc_DES, alloc_module, traffic, from_des):\\n node_src = topology_src\\n DES_dst = alloc_module[app_name][message.dst] # returns an array with all DES process serving\\n\\n if message.dst not in self.rr.keys():\\n self.rr[message.dst] = 0\\n\\n # print (\\\"GET PATH\\\")\\n # print (\\\"\\\\tNode _ src (id_topology): %i\\\" % node_src)\\n # print (\\\"\\\\tRequest service: %s \\\" % (message.dst))\\n # print (\\\"\\\\tProcess serving that service: %s (pos ID: %i)\\\" % (DES_dst, self.rr[message.dst]))\\n\\n bestPath = []\\n bestDES = []\\n\\n for ix, des in enumerate(DES_dst):\\n if message.name == \\\"RawVideo\\\" or message.name == \\\"IdentifyObject\\\":\\n if self.rr[message.dst] == ix:\\n dst_node = alloc_DES[des]\\n\\n path = list(nx.shortest_path(sim.topology.G, source=node_src, target=dst_node, weight='BW'))\\n\\n bestPath = [path]\\n bestDES = [des]\\n\\n self.rr[message.dst] = (self.rr[message.dst] + 1) % len(DES_dst)\\n break\\n else: # message.name == \\\"M.B\\\"\\n\\n dst_node = alloc_DES[des]\\n\\n path = list(nx.shortest_path(sim.topology.G, source=node_src, target=dst_node, weight='BW'))\\n if message.broadcasting:\\n bestPath.append(path)\\n bestDES.append(des)\\n else:\\n bestPath = [path]\\n bestDES = [des]\\n\\n return bestPath, bestDES\",\n \"def find_all_feedback_from_FVS(lt_links, ls_FVS=None):\\n if not ls_FVS:\\n set_nodes = set([])\\n for t_link in lt_links:\\n set_nodes.add(t_link[0])\\n set_nodes.add(t_link[1])\\n ls_FVS = FVS_analysis.FVS_finding(list(set_nodes), lt_links)[0]\\n #if FVS nodes are already gained, pass this step\\n \\n llt_feedbacks = []\\n dic_ts_FVSnodepair_llt_downstreams = {}#{(FVS node1, FVS node2):list of lt_downstream which starts at FVS node1 and ends at FVS node2}\\n for s_FVSnode in ls_FVS:\\n llt_downstreams = find_all_downstream_from_seed(lt_links, s_FVSnode, ls_FVS)\\n for lt_downstream in llt_downstreams:\\n ts_FVSpair = (s_FVSnode, lt_downstream[-1][-1])\\n dic_ts_FVSnodepair_llt_downstreams.setdefault(ts_FVSpair,[]).append(lt_downstream)\\n \\n lts_cyclesofFVS = get_all_cycles(ls_FVS)\\n for ts_cycleofFVS in lts_cyclesofFVS:\\n if len(ts_cycleofFVS) == 1:\\n llt_feedbacks.extend(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[0],ts_cycleofFVS[0])])\\n else:\\n b_stopflag = False\\n lllt_feedbackfragment = []\\n for i in range(len(ts_cycleofFVS)-1):\\n lllt_feedbackfragment.append(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[i], ts_cycleofFVS[i+1])])\\n if not dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[i], ts_cycleofFVS[i+1])]:\\n b_stopflag = True\\n break\\n lllt_feedbackfragment.append(dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[-1],ts_cycleofFVS[0])])\\n if not dic_ts_FVSnodepair_llt_downstreams[(ts_cycleofFVS[-1],ts_cycleofFVS[0])]:\\n b_stopflag = True\\n if b_stopflag:\\n continue#if there is no feedback passing by all FVS nodes of that cycle, pass to next cycle\\n \\n llt_feedbacks_specific_cycle = lllt_feedbackfragment.pop(0)\\n while lllt_feedbackfragment:\\n llt_fragments_next = lllt_feedbackfragment.pop(0)\\n llt_feedbacks_updated = []\\n for lt_fragment in llt_feedbacks_specific_cycle:\\n for lt_fragment_next in llt_fragments_next:\\n ls_route = [t_link[1] for t_link in lt_fragment[:-1]]\\n ls_route_next = [t_link[1] for t_link in lt_fragment_next[:-1]]\\n if not set(ls_route).intersection(set(ls_route_next)):\\n llt_feedbacks_updated.append(lt_fragment+lt_fragment_next)\\n llt_feedbacks_specific_cycle = llt_feedbacks_updated\\n llt_feedbacks.extend(llt_feedbacks_specific_cycle)\\n\\n return llt_feedbacks\",\n \"def test_get_dependencies_subgraph_by_dfs(\\n self, source_node, expected_nodes_in, expected_nodes_out\\n ):\\n graph = nx.DiGraph()\\n graph.add_node(\\\"pack1\\\")\\n graph.add_node(\\\"pack2\\\")\\n graph.add_node(\\\"pack3\\\")\\n graph.add_node(\\\"pack4\\\")\\n graph.add_edge(\\\"pack1\\\", \\\"pack2\\\")\\n graph.add_edge(\\\"pack2\\\", \\\"pack3\\\")\\n dfs_graph = PackDependencies.get_dependencies_subgraph_by_dfs(\\n graph, source_node\\n )\\n for i in expected_nodes_in:\\n assert i in dfs_graph.nodes()\\n for i in expected_nodes_out:\\n assert i not in dfs_graph.nodes()\",\n \"def find_sharpest_fork_general(Nodes):\\n pair_list = []\\n Dis = np.array([])\\n for n in Nodes:\\n if n.parent is not None:\\n if n.parent.parent is not None:\\n a = n.parent.children\\n if(isinstance(a, list)):\\n if(len(a)==2):\\n n1 = a[0]\\n n2 = a[1]\\n pair_list.append([n1 , n2])\\n dis = LA.norm(a[0].xyz - a[1].xyz,2)\\n Dis = np.append(Dis,dis)\\n if(len(Dis)!= 0):\\n (b,) = np.where(Dis == Dis.min())\\n sharpest_pair = pair_list[b[0]]\\n distance = Dis.min()\\n else:\\n sharpest_pair = [0,0]\\n distance = 0.\\n return sharpest_pair, distance\",\n \"def get_bfs(self, s):\\n # create a queue for BFS\\n queue = []\\n # mark all the vertices as not visited\\n visited = [False] * (len(self.graph))\\n # mark the start node as visited and enqueue it\\n visited[s] = True\\n queue.append(s)\\n results = []\\n\\n while queue:\\n # dequeue a vertex from queue and append to results.\\n p = queue.pop(0)\\n results.append(p)\\n # get all adjacent vertices of the dequeued vertex s,\\n # and for any unvisited adjacent, mark it visited and enqueue it.\\n for v in self.graph[p]:\\n if visited[v] is False:\\n visited[v] = True\\n queue.append(v)\\n\\n return results\",\n \"def sinks(self):\\n if self.rank < self.midpoint:\\n partner = self.midpoint + (self.rank - self.left)\\n if partner == self.right:\\n partner -= 1\\n else:\\n partner = self.left + (self.rank - self.midpoint)\\n if partner == self.midpoint:\\n partner -= 1\\n\\n return {partner}\",\n \"def bfs_traversal(graph, s, goals=[]):\\n visited = []\\n boundary = deque([s])\\n while len(boundary) > 0:\\n v = boundary.popleft()\\n visited += [v]\\n if v in goals:\\n return visited\\n for w in neighbours(v, graph):\\n if w not in visited and w not in boundary:\\n boundary.append(w)\\n return visited\\n\\n \\\"\\\"\\\"\\n visited = []\\n boundary = [s]\\n while len(boundary) > 0:\\n v = boundary.pop(0)\\n visited += [v]\\n for w in neighbours(v, graph):\\n if w not in goals:\\n if w not in visited and w not in boundary:\\n boundary.append(w)\\n else:\\n if w not in visited and w not in boundary:\\n boundary.append(w)\\n v = boundary.pop(0)\\n visited += [v]\\n break\\n return visited\\n \\\"\\\"\\\"\",\n \"def refugia_adj_5_simsplit(params, ns):\\n #20 parameters \\n nu1a, nu2a, nu3a, nu1b, nu2b, nu3b, m2_12, m2_13, m2_21, m2_23, m2_31, m2_32, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T2, T3 = params\\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\\n fs = moments.Spectrum(sts)\\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2]) \\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\\n ## Population function and migration matrix for T2\\n nu_T2 = [nu1a, nu2a, nu3a]\\n mig2 = numpy.array([[0, m2_12, m2_13],[m2_21, 0, m2_23], [m2_31, m2_32, 0]]) \\n fs.integrate(nu_T2, T2, m=mig2)\\n ## Population function and migration matrix for T3\\n nu_T3 = [nu1b, nu2b, nu3b]\\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \\n fs.integrate(nu_T3, T3, m=mig3) \\n return fs\",\n \"def dfs_edges_generator(graph, source, reverse=...):\\n ...\",\n \"def bfs_edges_generator(graph, source, reverse=...):\\n ...\",\n \"def bfs_path(graph, s, goals=[]):\\n visited = []\\n parents = [None]*len(graph)\\n boundary = [s]\\n while len(boundary) > 0:\\n v = boundary.pop(0)\\n visited += [v]\\n for w in neighbours(v, graph):\\n if w not in visited and w not in boundary:\\n boundary.append(w)\\n parents[w] = v\\n #w's parent\\n # put w's parent in the partent list\\n return get_path(parents, goals[0], goals[1])\",\n \"def compute_path_hopping_flow_allocations(target_graph, K=3):\\n flow_allocation_seed_number = 0xCAFE_BABE\\n np.random.seed(flow_allocation_seed_number)\\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\\n link_utilization = {(u, v): 0.0 for u, v in target_graph.edges}\\n node_capacity = {u: 0.0 for u in target_graph.nodes}\\n flows = []\\n while True:\\n source_node, destination_node = flow_selection_fn(target_graph.nodes, 2, replace=False)\\n print(source_node, destination_node)\\n\\n shortest_paths = sorted(nx.all_simple_paths(target_graph, source_node, destination_node,\\n cutoff=3),\\n key=lambda p: len(p))\\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\\n\\n # flow_tx_rate = np.random.uniform() * 10\\n flow_tx_rate = 1.0\\n # if node_capacity[source_node] + flow_tx_rate > LINK_CAPACITY:\\n # break\\n node_capacity[source_node] += flow_tx_rate\\n capacity_was_exceeded = False \\n for path in [nx.utils.pairwise(p_i) for p_i in k_shortest_paths]:\\n for u, v in [sorted(h_i) for h_i in path]:\\n flow_rate_per_subpath = flow_tx_rate / K\\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\\n capacity_was_exceeded = True\\n break\\n link_utilization[u, v] += flow_rate_per_subpath\\n if capacity_was_exceeded:\\n break\\n\\n if capacity_was_exceeded:\\n break\\n\\n the_flow = Flow( source_node = source_node\\n , destination_node = destination_node\\n , flow_tx_rate = flow_tx_rate\\n , paths = k_shortest_paths\\n , splitting_ratio = [1.0/K]*K\\n )\\n flows.append(the_flow)\\n return flows, link_utilization\",\n \"def _compute_longest_path_cut(self, src_uid, dst_uid):\\n # NOTE: at the time being the reason why it was chosen to include edges\\n # that belong to any path to the returned list, is unclear to me.\\n to_visit_uids = [dst_uid]\\n node_costs = {}\\n node_succs = {}\\n subgraph_edge_uids = []\\n subgraph_node_uids = [src_uid]\\n dsp = 0\\n\\n if (src_uid == dst_uid): # NOTE: deals with single-block graphs\\n node = self._nodes[src_uid]\\n return node.get_cost(), [src_uid], [], []\\n\\n # NOTE: the generated block graph might contain dead ends, thus\\n # visited_uids must be pre-computed\\n visited_uids = copy.deepcopy(self._nodes.keys())\\n lvisited_uids = []\\n while len(to_visit_uids) > 0:\\n cur_uid = to_visit_uids[0]\\n cur_node = self._nodes[cur_uid]\\n\\n if cur_uid in visited_uids:\\n visited_uids.remove(cur_uid)\\n\\n for pred_uid in cur_node.get_predecessors():\\n if pred_uid not in to_visit_uids and pred_uid not in lvisited_uids:\\n to_visit_uids.append(pred_uid)\\n\\n to_visit_uids = to_visit_uids[1:]\\n lvisited_uids.append(cur_uid)\\n\\n to_visit_uids = [dst_uid]\\n\\n # reverse graph exploration\\n while 0 < len(to_visit_uids):\\n assert(dsp < len(to_visit_uids))\\t# dead ends or loops\\n\\n cur_uid = to_visit_uids[dsp]\\n cur_node = self._nodes[cur_uid]\\n\\n assert(cur_uid != src_uid)\\n assert(cur_uid not in visited_uids)\\t# loop!\\n\\n # skip node for which there is still some unexplored successor\\n skip_uid = False\\n for succ_uid in cur_node.get_successors():\\n if not succ_uid in visited_uids:\\n skip_uid = True\\n\\n if skip_uid:\\n dsp += 1\\n continue\\n else:\\n dsp = 0\\n\\n if cur_uid == dst_uid:\\n node_costs[cur_uid] = cur_node.get_cost()\\n\\n for pred_uid in cur_node.get_predecessors():\\n pred_node = self._nodes[pred_uid]\\n # get edge pred_uid ---> cur_uid\\n edge_uid = Edge.get_edge_uid(pred_uid, cur_uid)\\n edge = self._edges[edge_uid]\\n edge_cost = edge.get_cost()\\n if edge_uid not in subgraph_edge_uids:\\n subgraph_edge_uids.append(edge_uid)\\n\\n # update node distance\\n pred_node_cost = node_costs[cur_uid] + edge_cost + pred_node.get_cost()\\n if pred_uid not in node_costs or pred_node_cost > node_costs[pred_uid]:\\n node_costs[pred_uid] = pred_node_cost\\n node_succs[pred_uid] = cur_uid\\n\\n # update to_visit_uids, a node cannot be visited more than once\\n if (pred_uid != src_uid) and (pred_uid not in visited_uids) \\\\\\n and (pred_uid not in to_visit_uids):\\n to_visit_uids.append(pred_uid)\\n\\n to_visit_uids.remove(cur_uid)\\n visited_uids.append(cur_uid)\\n subgraph_node_uids.append(cur_uid)\\n\\n # construct path from src_node to dst_node\\n cur_uid = src_uid\\n maxpath_node_uids = [cur_uid]\\n while cur_uid != dst_uid:\\n cur_uid = node_succs[cur_uid]\\n cur_node = self._nodes[cur_uid]\\n if cur_uid not in maxpath_node_uids:\\n maxpath_node_uids.append(cur_uid)\\n else:\\n raise Exception(\\\"invalid input source code graph: loop detected\\\")\\n\\n max_cost = node_costs[src_uid]\\n return max_cost, maxpath_node_uids, subgraph_node_uids, subgraph_edge_uids\",\n \"def _compute_paths_among(self, src_uid, dst_uid):\\n to_visit_uids = [dst_uid]\\n paths = {}\\n idx = 0\\n dsp = 0\\n\\n if (src_uid == dst_uid): # NOTE: deals with single-block graphs\\n return [src_uid]\\n\\n # NOTE: the generated block graph might contain dead ends, thus\\n # visited_uids must be pre-computed\\n visited_uids = copy.deepcopy(self._nodes.keys())\\n lvisited_uids = []\\n while len(to_visit_uids) > 0:\\n cur_uid = to_visit_uids[0]\\n cur_node = self._nodes[cur_uid]\\n\\n if cur_uid in visited_uids:\\n visited_uids.remove(cur_uid)\\n\\n for pred_uid in cur_node.get_predecessors():\\n if pred_uid not in to_visit_uids and pred_uid not in lvisited_uids:\\n to_visit_uids.append(pred_uid)\\n\\n to_visit_uids = to_visit_uids[1:]\\n lvisited_uids.append(cur_uid)\\n\\n to_visit_uids = [dst_uid]\\n\\n while idx < len(to_visit_uids):\\n assert(idx + dsp < len(to_visit_uids))\\n\\n cur_uid = to_visit_uids[idx + dsp]\\n cur_node = self._nodes[cur_uid]\\n\\n assert(cur_uid != src_uid)\\n assert(cur_uid not in visited_uids)\\n\\n # skip node for which there is still some unexplored successor\\n skip_uid = False\\n for succ_uid in cur_node.get_successors():\\n if succ_uid not in visited_uids:\\n skip_uid = True\\n\\n if skip_uid:\\n dsp += 1\\n continue\\n else:\\n dsp = 0\\n\\n if cur_uid == dst_uid:\\n paths[cur_uid] = 1\\n\\n for pred_uid in cur_node.get_predecessors():\\n if pred_uid not in paths:\\n paths[pred_uid] = paths[cur_uid]\\n else:\\n paths[pred_uid] += paths[cur_uid]\\n\\n # a node cannot be visited more than once\\n if pred_uid != src_uid and pred_uid not in visited_uids \\\\\\n and pred_uid not in to_visit_uids:\\n to_visit_uids.append(pred_uid)\\n\\n to_visit_uids.remove(cur_uid)\\n visited_uids.append(cur_uid)\\n\\n return paths[src_uid]\",\n \"def get_skims(G, transfer_penalty=300, delta=0.2):\\n # shortest path\\n sp = nx.shortest_path(G, weight='total_travel_time')\\n # create a dictionary for stop travel impedance values\\n # The travel impedance is also decomposed\\n # GTC: total generalized travel cost\\n # IVT: in-vehicle travel time\\n # NONIVT: the remaining part related to transfer and waiting times\\n ti = {}\\n fields = ['GTC', \\\"IVT\\\", \\\"WT\\\", \\\"TRANSFER\\\", \\\"NONIVT\\\"]\\n for key in sp.keys():\\n ti[key] = {}\\n for field in fields:\\n ti[key][field] = dict()\\n for source in sp.keys():\\n for target in sp[source].keys():\\n cur_sp = sp[source][target]\\n for field in fields:\\n ti[source][field][target] = 0\\n if not len(cur_sp) == 1:\\n # if not the node itself\\n for k in range(len(cur_sp) - 1):\\n i = cur_sp[k]\\n j = cur_sp[k + 1]\\n ti[source]['IVT'][target] += G[i][j]['ivt']\\n ti[source]['WT'][target] += G[i][j]['wt']\\n ti[source]['NONIVT'][target] += G[i][j]['wt']\\n ti[source]['NONIVT'][target] += (len(cur_sp) - 2) * transfer_penalty\\n ti[source]['TRANSFER'][target] = (len(cur_sp) - 2) * transfer_penalty\\n ti[source]['GTC'][target] = ti[source]['IVT'][target] + ti[source]['NONIVT'][target]\\n\\n skims = DotMap()\\n for field in fields:\\n skims[field] = pd.DataFrame([ti[i][field] for i in sp.keys()], index=sp.keys())\\n\\n x_list = list(nx.get_node_attributes(G, 'x').values())\\n y_list = list(nx.get_node_attributes(G, 'y').values())\\n df = pd.DataFrame({'node_id': list(sp.keys()), 'x': x_list, 'y': y_list})\\n df = df.set_index('node_id')\\n\\n skims['pos'] = df\\n return skims\",\n \"def get_routing_solution(self):\\n G = self.base_digraph\\n s1 = self.sources[0]\\n s2 = self.sources[1]\\n t1 = self.destinations[0]\\n t2 = self.destinations[1]\\n\\n try:\\n m = Model('routing')\\n m.setParam('OutputFlag', False)\\n\\n # variables,\\n # We have one variable per edge per session\\n # e is the dict of dict for the variables\\n e = {}\\n r = {}\\n for i in [1,2]:\\n e[i] = {}\\n r[i] = m.addVar()\\n for u,v in G.edges():\\n e[i][u,v] = m.addVar(lb=0)\\n\\n m.update()\\n\\n obj = quicksum(r.values())\\n m.setObjective(obj, GRB.MAXIMIZE)\\n\\n # constraints\\n # 1. conservations of flow at all intermediate nodes\\n # 2. capacity constraints for each edge\\n\\n for u,v in G.edges():\\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\\n\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\\n\\n for n in G.nodes():\\n if n not in [s1, s2, t1, t2]:\\n for i in [1, 2]:\\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\\n m.addConstr(inflow == outflow)\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n for u, v in G.edges():\\n G[u][v]['Routing'] = {}\\n G[u][v]['Routing'][1] = e[1][u,v].x\\n G[u][v]['Routing'][2] = e[2][u,v].x\\n return (m.objVal, r[1].x, r[2].x)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong, no optimal solution obtained\\\"\\n return None, None, None\\n\\n except GurobiError:\\n Print ('Error Report from Gurobi')\",\n \"def dfs_path(graph, s, goals=[]):\\n visited = []\\n parents = [None]*(len(graph))\\n boundary = [s]\\n while len(boundary) > 0:\\n v = boundary.pop()\\n visited += [v]\\n for w in neighbours(v, graph):\\n if w not in visited and w not in boundary:\\n boundary.append(w)\\n parents[w] = v\\n return get_path(parents, goals[0], goals[1])\",\n \"def caculate_network_statistics(self):\\n divide_factor_sum = 0 \\n for key in self.stars.keys():\\n star = self.stars[key]\\n if star.nb_num == 0 :\\n self.standalone_star_num += 1 \\n\\n divide_factor = star.nb_num + 2 * (star.spec_num - star.shared_spec_num )/self.ave_starlet_size\\n divide_factor_sum += divide_factor\\n divide_factor_int = round(divide_factor)\\n self.star_divide_factor_dist[divide_factor_int] = self.star_divide_factor_dist.get(divide_factor_int,0) + 1\\n if star.spec_num < star.shared_spec_num:\\n print(\\\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\\\")\\n print(\\\"with star \\\" + star.id + \\\" \\\" + str(star.spec_num) + \\\"is less than\\\" + str(star.shared_spec_num))\\n if star.spec_num > star.shared_spec_num:\\n self.star_lost_spec_num += star.spec_num - star.shared_spec_num\\n self.ave_divide_factor_star = divide_factor_sum/self.stars_length\\n\\n divide_factor_sum = 0 \\n for key in self.starlets.keys():\\n starlet = self.starlets[key]\\n if starlet.nb_num == 0 :\\n self.standalone_starlet_num += 1 \\n\\n divide_factor = starlet.nb_num + 2 * (starlet.spec_num - starlet.shared_spec_num )/self.ave_star_size\\n divide_factor_sum += divide_factor\\n divide_factor_int = round(divide_factor)\\n self.starlet_divide_factor_dist[divide_factor_int] = self.starlet_divide_factor_dist.get(divide_factor_int,0) + 1\\n if starlet.spec_num < starlet.shared_spec_num:\\n print(\\\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\\\")\\n print(\\\"with star \\\" + starlet.id + \\\" \\\" + str(starlet.spec_num) + \\\"is less than\\\" + str(starlet.shared_spec_num))\\n if starlet.spec_num > starlet.shared_spec_num:\\n self.starlet_lost_spec_num += starlet.spec_num - starlet.shared_spec_num\\n self.ave_divide_factor_starlet = divide_factor_sum/self.starlets_length\",\n \"def Sidetrack2Path(tree, sidetracks, s, t):\\n\\tvisited = set()\\t\\t# visited nodes\\n\\tpath = []\\t\\t# set of edges\\n\\tsidenodes = set(links[e][0] for e in sidetracks)\\t# nodes that needs to be sidetracked\\n\\tcurrent = s\\n\\twhile current != t:\\n\\t\\t# Loop detection\\n\\t\\tif current in visited:\\n\\t\\t\\treturn []\\n\\t\\telse:\\n\\t\\t\\tvisited.add(current)\\n\\t\\t# No loop is found yet, proceed one hop\\n\\t\\tif current in sidenodes:\\n\\t\\t\\tedge = [e for e in sidetracks if links[e][0] == current]\\n\\t\\t\\tcurrent = links[edge[0]][1]\\n\\t\\t\\tpath.append(edge[0])\\n\\t\\telse:\\n\\t\\t\\tedge = [i for i,e in enumerate(links) if e == (current,tree[current])]\\n\\t\\t\\tcurrent = links[edge[0]][1]\\n\\t\\t\\tpath.append(edge[0])\\n\\t# Destination reached. Return the path\\n\\treturn path\",\n \"def test_tree_splay() -> None:\\n t = generate_graph_resources(5)\\n field(t, (\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\")).references.append(\\n (FieldAddress(\\\"dr_2\\\", \\\"ds_2\\\", \\\"f1\\\"), \\\"to\\\")\\n )\\n field(t, (\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\")).references.append(\\n (FieldAddress(\\\"dr_3\\\", \\\"ds_3\\\", \\\"f1\\\"), \\\"to\\\")\\n )\\n field(t, (\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\")).references.append(\\n (FieldAddress(\\\"dr_4\\\", \\\"ds_4\\\", \\\"f1\\\"), \\\"to\\\")\\n )\\n field(t, (\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\")).references.append(\\n (FieldAddress(\\\"dr_5\\\", \\\"ds_5\\\", \\\"f1\\\"), \\\"to\\\")\\n )\\n field(t, (\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\")).identity = \\\"email\\\"\\n traversal = Traversal(DatasetGraph(*t), {\\\"email\\\": \\\"X\\\"})\\n\\n assert incoming_edges(traversal, CollectionAddress(\\\"dr_1\\\", \\\"ds_1\\\")) == {\\n Edge(\\n FieldAddress(\\\"__ROOT__\\\", \\\"__ROOT__\\\", \\\"email\\\"),\\n FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\"),\\n )\\n }\\n assert outgoing_edges(traversal, CollectionAddress(\\\"dr_1\\\", \\\"ds_1\\\")) == {\\n Edge(FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\"), FieldAddress(\\\"dr_3\\\", \\\"ds_3\\\", \\\"f1\\\")),\\n Edge(FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\"), FieldAddress(\\\"dr_4\\\", \\\"ds_4\\\", \\\"f1\\\")),\\n Edge(FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\"), FieldAddress(\\\"dr_5\\\", \\\"ds_5\\\", \\\"f1\\\")),\\n Edge(FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\"), FieldAddress(\\\"dr_2\\\", \\\"ds_2\\\", \\\"f1\\\")),\\n }\\n\\n assert outgoing_edges(traversal, CollectionAddress(\\\"dr_5\\\", \\\"ds_5\\\")) == set()\\n assert incoming_edges(traversal, CollectionAddress(\\\"dr_2\\\", \\\"ds_2\\\")) == {\\n Edge(FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\"), FieldAddress(\\\"dr_2\\\", \\\"ds_2\\\", \\\"f1\\\"))\\n }\\n assert incoming_edges(traversal, CollectionAddress(\\\"dr_3\\\", \\\"ds_3\\\")) == {\\n Edge(FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\"), FieldAddress(\\\"dr_3\\\", \\\"ds_3\\\", \\\"f1\\\"))\\n }\\n assert incoming_edges(traversal, CollectionAddress(\\\"dr_4\\\", \\\"ds_4\\\")) == {\\n Edge(FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\"), FieldAddress(\\\"dr_4\\\", \\\"ds_4\\\", \\\"f1\\\"))\\n }\\n assert incoming_edges(traversal, CollectionAddress(\\\"dr_5\\\", \\\"ds_5\\\")) == {\\n Edge(FieldAddress(\\\"dr_1\\\", \\\"ds_1\\\", \\\"f1\\\"), FieldAddress(\\\"dr_5\\\", \\\"ds_5\\\", \\\"f1\\\"))\\n }\\n traversal_map, terminators = traversal.traversal_map()\\n assert traversal_map == {\\n \\\"__ROOT__:__ROOT__\\\": {\\\"from\\\": {}, \\\"to\\\": {\\\"dr_1:ds_1\\\": {\\\"email -> f1\\\"}}},\\n \\\"dr_1:ds_1\\\": {\\n \\\"from\\\": {\\\"__ROOT__:__ROOT__\\\": {\\\"email -> f1\\\"}},\\n \\\"to\\\": {\\n \\\"dr_2:ds_2\\\": {\\\"f1 -> f1\\\"},\\n \\\"dr_3:ds_3\\\": {\\\"f1 -> f1\\\"},\\n \\\"dr_4:ds_4\\\": {\\\"f1 -> f1\\\"},\\n \\\"dr_5:ds_5\\\": {\\\"f1 -> f1\\\"},\\n },\\n },\\n \\\"dr_2:ds_2\\\": {\\\"from\\\": {\\\"dr_1:ds_1\\\": {\\\"f1 -> f1\\\"}}, \\\"to\\\": {}},\\n \\\"dr_3:ds_3\\\": {\\\"from\\\": {\\\"dr_1:ds_1\\\": {\\\"f1 -> f1\\\"}}, \\\"to\\\": {}},\\n \\\"dr_4:ds_4\\\": {\\\"from\\\": {\\\"dr_1:ds_1\\\": {\\\"f1 -> f1\\\"}}, \\\"to\\\": {}},\\n \\\"dr_5:ds_5\\\": {\\\"from\\\": {\\\"dr_1:ds_1\\\": {\\\"f1 -> f1\\\"}}, \\\"to\\\": {}},\\n }\\n\\n assert set(terminators) == {\\n CollectionAddress(\\\"dr_2\\\", \\\"ds_2\\\"),\\n CollectionAddress(\\\"dr_3\\\", \\\"ds_3\\\"),\\n CollectionAddress(\\\"dr_4\\\", \\\"ds_4\\\"),\\n CollectionAddress(\\\"dr_5\\\", \\\"ds_5\\\"),\\n }\",\n \"def get_weight_from_minflow(self):\\n start_nodes = []\\n end_nodes = []\\n capacities = []\\n unit_costs = []\\n A = 0\\n s_prime = self.sink() + 1\\n t_prime = self.sink() + 2\\n x = self.sink() + 3\\n # for every edge in the graph, add edge to mincost flow instance with\\n # infinite capacity and cost 1\\n # also add backwards edge\\n for arc in self.arc_info.keys():\\n # forward edge\\n start_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"start\\\"],\\n self.arc_info[arc][\\\"destin\\\"]))\\n # backward edge\\n start_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n capacities.append(int(self.arc_info[arc][\\\"weight\\\"])) # no negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"destin\\\"],\\n self.arc_info[arc][\\\"start\\\"]))\\n # add (x,s) and (t,x) edges with same cap, cost as above\\n in_weight_x = 0\\n for in_arc in self.in_arcs_lists[self.sink()]:\\n in_weight_x += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight_x = 0\\n for out_arc in self.out_arcs_lists[self.source()]:\\n out_weight_x += self.arc_info[out_arc][\\\"weight\\\"]\\n # (x,s)\\n start_nodes.append(x)\\n end_nodes.append(self.source())\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.source()))\\n # backward\\n start_nodes.append(self.source())\\n end_nodes.append(x)\\n capacities.append(int(out_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.source(),\\n x))\\n # (t,x)\\n start_nodes.append(self.sink())\\n end_nodes.append(x)\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.sink(),\\n x))\\n # backward\\n start_nodes.append(x)\\n end_nodes.append(self.sink())\\n capacities.append(int(in_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.sink()))\\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\\n # and cost 0.\\n for v in self:\\n # process internal verts only, since we assume source and sink have\\n # no in and out edges respectively\\n if v != self.source() and v != self.sink():\\n # compute a-exc(v)\\n in_weight = 0\\n for in_arc in self.in_arcs_lists[v]:\\n in_weight += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight = 0\\n for out_arc in self.out_arcs_lists[v]:\\n out_weight += self.arc_info[out_arc][\\\"weight\\\"]\\n a_exc = out_weight - in_weight\\n if a_exc < 0:\\n # add edge (s', v)\\n start_nodes.append(s_prime)\\n end_nodes.append(v)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n v,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (v, t')\\n start_nodes.append(v)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n v,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # process x node\\n a_exc = out_weight_x - in_weight_x\\n if a_exc < 0:\\n # add edge (s', x)\\n start_nodes.append(s_prime)\\n end_nodes.append(x)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n x,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (x, t')\\n start_nodes.append(x)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n x,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # we must send flow of A from s_prime to t_prime\\n supplies = [0]*(len(self) + 3)\\n supplies[s_prime] = int(A)\\n supplies[t_prime] = int(-A)\\n # Instantiate a SimpleMinCostFlow solver.\\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\\n # Add each arc.\\n for i in range(len(start_nodes)):\\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\\n end_nodes[i], capacities[i], unit_costs[i])\\n # Add node supplies\\n for i in range(0, len(supplies)):\\n min_cost_flow.SetNodeSupply(i, supplies[i])\\n # Find the minimum cost flow between node s' and t'.\\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\\n print('Minimum cost:', min_cost_flow.OptimalCost())\\n print('')\\n print(' Arc Flow / Capacity Cost')\\n for i in range(min_cost_flow.NumArcs()):\\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\\n print('%1s -> %1s %3s / %3s %3s' % (\\n min_cost_flow.Tail(i),\\n min_cost_flow.Head(i),\\n min_cost_flow.Flow(i),\\n min_cost_flow.Capacity(i),\\n cost))\\n # update arcs\\n start = min_cost_flow.Tail(i)\\n destin = min_cost_flow.Head(i)\\n if start != s_prime and \\\\\\n start != t_prime and \\\\\\n start != x and \\\\\\n destin != s_prime and \\\\\\n destin != t_prime and \\\\\\n destin != x:\\n # if forward, increase flow. otherwise decrease.\\n print(\\\"Processing edge ({}, {})\\\".format(start, destin))\\n if start < destin:\\n sup_flow = min_cost_flow.Flow(i)\\n else:\\n sup_flow = -min_cost_flow.Flow(i)\\n temp_start = start\\n start = destin\\n destin = temp_start\\n print(\\\"Has become ({}, {}) with sup {}\\\".format(start,\\n destin,\\n sup_flow))\\n arc = self.get_arc(start, destin)\\n if (sup_flow != 0) or (\\\"lower_bound\\\" not in \\\\\\n self.arc_info[arc].keys()):\\n print(\\\"We should add this\\\")\\n old_flow = self.arc_info[arc][\\\"weight\\\"]\\n new_flow = old_flow + sup_flow\\n self.arc_info[arc][\\\"weight\\\"] = int(new_flow)\\n print(\\\"Edge ({},{}) weight is changed from {} to {}\\\".format(\\n start,\\n destin,\\n old_flow,\\n new_flow))\\n else:\\n print('There was an issue with the min cost flow input.')\\n #self.check_conservation_of_flow() # check that solution is valid\",\n \"def find_ports(self, lines):\\n ports = []\\n left = None\\n self.dists = []\\n for line in lines:\\n if left is None:\\n if self.is_left(line):\\n left = self.mid(line)\\n else:\\n if not self.is_left(line):\\n ports.append(int(left[0] + self.mid(line)[0]) // 2)\\n self.dists.append(left[0] - self.mid(line)[0])\\n left = None\\n # print(ports)\\n return ports\",\n \"def bfs_nodes_generator(graph, source, reverse=...):\\n ...\",\n \"def max_flow(self, source, sink):\\n\\n path = self.valid_path(source, sink, [])\\n\\n while path:\\n # get the maximum possible flow that can be taken from this path:\\n max_flow = min([edge.capacity for edge in path])\\n for edge in path:\\n self.edges[edge] += max_flow\\n path = self.valid_path(source, sink, [])\\n\\n # Compute all the flows from the neighbors of source:\\n return sum([self.edges[edge] for edge in self.adjacents[source]])\",\n \"def nodes_ratio(data: Data, position_against_soma=None, node_types=None, filter_layers=None):\\n soma = data.morphology.get_soma()\\n if position_against_soma=='above':\\n criterion=lambda nod:((nod['type'] in node_types) if node_types is not None else True) and nod['y']<soma['y']\\n elif position_against_soma=='below':\\n criterion=lambda nod:((nod['type'] in node_types) if node_types is not None else True) and nod['y']>soma['y']\\n else:\\n criterion=lambda nod:nod['type'] in node_types if node_types is not None else True\\n num_type_nodes = data.morphology.get_node_by_types(node_types)\\n if filter_layers and isinstance(filter_layers, list):\\n result = {}\\n for layer in filter_layers:\\n filter_layer_depth = data.reference_layer_depths.get(layer)\\n y_min, y_max, is_scale = filter_layer_depth.pia_side, filter_layer_depth.wm_side, filter_layer_depth.scale\\n if is_scale:\\n selected_nodes = data.morphology.filter_nodes(lambda nod: criterion(nod) and y_min<nod['y']<y_max)\\n else:\\n selected_nodes = data.morphology.filter_nodes(lambda nod: criterion(nod) and nod['y']>y_min)\\n result[layer]=len(selected_nodes)/len(num_type_nodes)\\n return result\\n else:\\n selected_nodes = data.morphology.filter_nodes(criterion)\\n return len(selected_nodes)/len(num_type_nodes)\",\n \"def get_fraction_links_active(self):\\n active_links = 0\\n for (a,b) in self.model.model.edges_iter():\\n (a_id, a_traits) = self.model.get_agent_by_id(a)\\n (b_id, b_traits) = self.model.get_agent_by_id(b)\\n prob = analysis.calc_probability_interaction_axelrod(a_traits, b_traits)\\n if prob > 0.0 and prob < 1.0:\\n #log.debug(\\\"active link (%s %s) prob: %s a_trait: %s b_trait: %s\\\", a_id, b_id, prob, a_traits, b_traits)\\n active_links += 1\\n num_links_total = self.model.model.number_of_edges()\\n #log.debug(\\\"active links: %s total links: %s\\\", active_links, num_links_total)\\n fraction_active = float(active_links) / num_links_total\\n return fraction_active\",\n \"def find_sharpest_fork(nodes):\\n pair_list = []\\n Dis = np.array([])\\n for n in nodes:\\n if n.parent is not None:\\n if n.parent.parent is not None:\\n a = n.parent.children\\n if(isinstance(a, list)):\\n if(len(a)==2):\\n n1 = a[0]\\n n2 = a[1]\\n if(len(n1.children) == 0 and len(n2.children) == 0):\\n pair_list.append([n1 , n2])\\n dis = LA.norm(a[0].xyz - a[1].xyz,2)\\n Dis = np.append(Dis,dis)\\n if(len(Dis)!= 0):\\n (b,) = np.where(Dis == Dis.min())\\n sharpest_pair = pair_list[b[0]]\\n distance = Dis.min()\\n else:\\n sharpest_pair = [0,0]\\n distance = 0.\\n return sharpest_pair, distance\",\n \"def bfs_paths(self, start: str, goal: str) -> List[Path]:\\n queue = [(start, [start])]\\n while queue:\\n (node, path) = queue.pop(0)\\n if node not in self.graph:\\n yield []\\n for _next in set(self.graph[node]) - set(path):\\n if _next == goal:\\n yield path + [_next]\\n elif _next in self.graph:\\n queue.append((_next, path + [_next]))\",\n \"def get_all_social_paths(self, user_id): #each user v v each path V V\\n # output example- {1: [1], 8: [1, 8], 10: [1, 10], 5: [1, 5], 2: [1, 10, 2], 6: [1, 10, 6], 7: [1, 10, 2, 7]}\\n visited = {} # Note that this is a dictionary, not a set\\n # Need to do a bfs using the user id\\n # first step is to traverse the graph and record all the vertices as keys in visited using bft\\n # then take those keys and use bfs on each, using user_id as the starting node and and the key as\\n # the destination node\\n\\n # Modification of BFT\\n # create an empty dict\\n # q = Queue()\\n q = []\\n\\n # init enqueue the starting node\\n q.append(user_id)\\n\\n while len(q) > 0:\\n # Dequeue the first item\\n v = q.pop(0)\\n # If it's not been visited:\\n if v not in visited:\\n # Mark as visited (i.e. add to the visited set)\\n visited[v] = []\\n\\n # Do something with the node\\n print(f\\\"Visited {v}\\\")\\n\\n # Add all neighbors to the queue\\n for next_vert in self.friendships[v]:\\n q.append(next_vert)\\n\\n # once visited is filled, then we start the bfs\\n #print('vv',visited)\\n possible_paths = {}\\n #run a bfs for each key in visited\\n for v in visited:\\n possible_paths[v] = []\\n \\n if v == user_id:\\n visited[v] = [user_id]\\n\\n path = []\\n while len(path) < len(visited):\\n\\n # Add all neighbors to the queue\\n for next_vert in self.friendships[v]:\\n print(possible_paths[v])\\n # copy the path\\n # temp_path = list(path)\\n # temp_path.append(next_vert)\\n # add path to possible_paths\\n path.append(next_vert)\\n\\n possible_paths[v].append(path) # HAVE TO USE QUEUE OR STACK, THEY ENSURE THE NEIGHBORS\\n # FOLLOW THE CORRECT ORDER WHEN LOOPING \\n\\n if v == path[-1]:\\n \\n # IF SO, RETURN PATH\\n visited[v] = path\\n break\\n\\n # for x in visited:\\n # bfs(user_id, x)\\n # visited[x].add(path)\\n \\n print('pct of total users in network', len(visited[1])/len(visited))\\n print('degrees of separation', len(visited[1]) - 1)\\n return visited\",\n \"def findrelations(planet, comingFrom, relations, borders):\\n transfers = []\\n transfersPath = 0\\n \\n relations = []\\n for i in relations:\\n if planet in i:\\n # both orbits and centers can be saved except itself and the one coming from\\n for j in i: \\n if j not in (planet, comingFrom):\\n relations.append(j)\\n \\n for rel in relations:\\n if rel == \\\"SAN\\\":\\n return transfers\\n elif rel not in borders:\\n transfers +=1\\n transfers += findrelations(rel, comingFrom, relations, borders)\\n \\n transfers.append(transfersPath-1)\\n return transfers\",\n \"def _get_full_graph(self):\",\n \"def path_to_actor(self, source, target):\\r\\n #shortest path\\r\\n path = nx.shortest_path(self.graph, source, target)\\r\\n #shortest path length....\\r\\n len_path = nx.shortest_path_length(self.graph, source, target)\\r\\n return path, len_path/2\",\n \"def get_fraction_links_active(self):\\n active_links = 0\\n for (a,b) in self.model.model.edges_iter():\\n (a_id, a_traits) = self.model.get_agent_by_id(a)\\n (b_id, b_traits) = self.model.get_agent_by_id(b)\\n prob = analysis.calc_probability_interaction_extensible(a_traits, b_traits)\\n if prob > 0.0 and prob < 1.0:\\n #log.debug(\\\"active link (%s %s) prob: %s a_trait: %s b_trait: %s\\\", a_id, b_id, prob, a_traits, b_traits)\\n active_links += 1\\n num_links_total = self.model.model.number_of_edges()\\n #log.debug(\\\"active links: %s total links: %s\\\", active_links, num_links_total)\\n fraction_active = float(active_links) / num_links_total\\n return fraction_active\",\n \"def createBridgeSets(blocksize,operating,MPSS):\\n sets = tuple()\\n xul = blocksize[0]-operating\\n xdl = operating\\n yul = int(blocksize[0]/2+operating)\\n ydl = int(blocksize[0]/2-operating)\\n xts = xul\\n xbs = xdl\\n for i in range(MPSS):\\n sets+=(tuple(product(numpy.arange(xdl,xul,1),numpy.arange(ydl,yul,1))),)\\n xdl+=operating\\n xul-=operating\\n ydl-=operating\\n yul+=operating\\n return sets,sets[::-1]\",\n \"def detect_splits(self):\\n logg.info(' abstracted graph will have {} nodes'.format(self.n_splits+1))\\n indices_all = np.arange(self.X.shape[0], dtype=int)\\n segs = [indices_all]\\n if False: # this is safe, but not compatible with on-the-fly computation\\n tips_all = np.array(np.unravel_index(np.argmax(self.Dchosen), self.Dchosen.shape))\\n else:\\n if self.iroot is not None:\\n tip_0 = np.argmax(self.Dchosen[self.iroot])\\n else:\\n tip_0 = np.argmax(self.Dchosen[0]) # just a random index, here fixed to \\\"0\\\"\\n tips_all = np.array([tip_0, np.argmax(self.Dchosen[tip_0])])\\n # we keep a list of the tips of each segment\\n segs_tips = [tips_all]\\n if self.clusters_precomputed_names:\\n self.segs_names_original = [', '.join(self.clusters_precomputed_names)]\\n segs_undecided = [True]\\n segs_adjacency = [[]]\\n segs_distances = np.zeros((1, 1))\\n segs_adjacency_nodes = [{}]\\n # logg.info(' do not consider groups with less than {} points for splitting'\\n # .format(self.min_group_size))\\n for ibranch in range(self.n_splits):\\n if self.clusters == 'unconstrained_segments':\\n iseg, new_tips = self.select_segment(segs, segs_tips, segs_undecided)\\n if iseg == -1:\\n logg.info('... partitioning converged')\\n break\\n logg.info('... branching {}:'.format(ibranch + 1),\\n 'split group', iseg)\\n segs_distances = self.do_split(segs, segs_tips,\\n segs_undecided,\\n segs_adjacency,\\n segs_distances,\\n iseg, new_tips)\\n else:\\n logg.msg(' split', ibranch + 1, v=4)\\n stop, segs_distances = self.do_split_constrained(segs, segs_tips,\\n segs_adjacency,\\n segs_adjacency_nodes,\\n segs_distances)\\n if stop: break\\n\\n # segments\\n self.segs = segs\\n self.segs_tips = segs_tips\\n self.segs_sizes = []\\n for iseg, seg in enumerate(self.segs): self.segs_sizes.append(len(seg))\\n\\n # the full, unscaled adjacency matrix\\n self.segs_adjacency_full_attachedness = 1/segs_distances\\n # if self.attachedness_measure == 'connectedness':\\n # norm = np.sqrt(np.multiply.outer(self.segs_sizes, self.segs_sizes))\\n # self.segs_adjacency_full_attachedness /= norm\\n self.segs_adjacency_full_confidence, self.segs_adjacency_tree_confidence \\\\\\n = self.compute_adjacency_confidence(\\n self.segs_adjacency_full_attachedness,\\n segs_adjacency,\\n self.tree_based_confidence)\\n np.fill_diagonal(self.segs_adjacency_full_attachedness, 0)\",\n \"def transmission (graph, r=.5, m=.5):\\n\\n routes = r*nx.adjacency_matrix(graph)\\n medicn = m*sp.eye(nx.number_of_nodes(graph))\\n\\n return routes + medicn\",\n \"def get_GNS_cut(self):\\n # we build the optimization around the casted digraph instead of multidigraph\\n # for simplicity\\n G = self.base_digraph\\n s_1 = self.sources[0]\\n s_2 = self.sources[1]\\n t_1 = self.destinations[0]\\n t_2 = self.destinations[1]\\n edges = G.edges()\\n nodes = G.nodes()\\n\\n try:\\n\\n # Great an gurobi instance of the optimization model\\n m = Model(\\\"GNS\\\")\\n m.setParam('OutputFlag', False)\\n\\n x_v = {}\\n # vertex variables for s_1, t_1 cut\\n for v in nodes:\\n x_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n x_e = {}\\n # edge variables for s_1, t_1 cut\\n for (u,v) in edges:\\n x_e[u,v] = m.addVar(vtype=GRB.BINARY)\\n\\n y_v = {}\\n # vertex variables for s_2, t_2 cut\\n for v in nodes:\\n y_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n y_e = {}\\n # edge variables for s_2, t_2 cut\\n for (u,v) in edges:\\n y_e[u,v] = m.addVar(vtype=GRB.BINARY)\\n\\n z_v = {}\\n # vertex variables for s_2, t_1 cut\\n for v in nodes:\\n z_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n z_e = {}\\n # edge variables for s_2, t_1 cut\\n for (u,v) in edges:\\n z_e[u,v] = m.addVar(vtype=GRB.BINARY)\\n\\n e = {}\\n # GNS indicator variable\\n for (u,v) in edges:\\n e[u,v] = m.addVar(vtype=GRB.BINARY, obj=G[u][v]['capacity'])\\n\\n # Done with decision variable creation\\n # update model\\n m.update()\\n\\n # Constraints\\n # 1. Constraints for s_1 - t_1 cut\\n for (u,v) in edges:\\n if (u,v) == (s_1, t_1):\\n m.addConstr(x_e[u,v] >= 1)\\n elif u == s_1:\\n m.addConstr(x_v[v] + x_e[u,v] >= 1)\\n elif v == t_1:\\n m.addConstr(-x_v[u] + x_e[u,v] >= 0)\\n else:\\n m.addConstr(x_v[v] - x_v[u] + x_e[u,v] >= 0)\\n\\n # 2. Constraints for s_2 - t_2 cut\\n for (u,v) in edges:\\n if (u,v) == (s_2, t_2):\\n m.addConstr(y_e[u,v] >= 1)\\n elif u == s_2:\\n m.addConstr(y_v[v] + y_e[u,v] >= 1)\\n elif v == t_2:\\n m.addConstr(-y_v[u] + y_e[u,v] >= 0)\\n else:\\n m.addConstr(y_v[v] - y_v[u] + y_e[u,v] >= 0)\\n\\n # 3. Constraints for s_2 - t_1 cut\\n for (u,v) in edges:\\n if (u,v) == (s_2, t_1):\\n m.addConstr(z_e[u,v] >= 1)\\n elif u == s_2:\\n m.addConstr(z_v[v] + z_e[u,v] >= 1)\\n elif v == t_1:\\n m.addConstr(-z_v[u] + z_e[u,v] >= 0)\\n else:\\n m.addConstr(z_v[v] - z_v[u] + z_e[u,v] >= 0)\\n\\n # 4. Constraints for e[u,v] >= max(x_e[u,v], y_e[u,v], z_e[u,v])\\n for (u,v) in edges:\\n m.addConstr(e[u,v] >= x_e[u,v])\\n m.addConstr(e[u,v] >= y_e[u,v])\\n m.addConstr(e[u,v] >= z_e[u,v])\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n print \\\"Min GNS cut value = \\\" + str(m.objVal)\\n print \\\"GNS cut edges:\\\"\\n\\n for u,v in edges:\\n if e[u,v].x != 0:\\n print (u,v)\\n print \\\"s1-t1 cut edges in GNS:\\\"\\n for u,v in edges:\\n if x_e[u,v].x != 0:\\n print (u,v)\\n\\n print \\\"s2-t2 cut edges in GNS:\\\"\\n for u,v in edges:\\n if y_e[u,v].x != 0:\\n print (u,v)\\n\\n print \\\"s2-t1 cut edges in GNS:\\\"\\n for u,v in edges:\\n if z_e[u,v].x != 0:\\n print (u,v)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong\\\"\\n\\n except GurobiError:\\n print ('Error report from Gurobi')\",\n \"def get_path(self, sim, app_name, message, topology_src, alloc_DES, alloc_module, traffic, from_des):\\n node_src = topology_src\\n DES_dst = alloc_module[app_name][message.dst]\\n\\n # print (\\\"GET PATH\\\")\\n # print (\\\"\\\\tNode _ src (id_topology): %i\\\" % node_src)\\n # print (\\\"\\\\tRequest service: %s \\\" % message.dst)\\n # print (\\\"\\\\tProcess serving that service: %s \\\" % DES_dst)\\n\\n bestPath = []\\n bestDES = []\\n min_path_size = float('inf')\\n myDigraph = graph2digraph(sim.topology.G)\\n\\n for des in DES_dst: ## In this case, there are only one deployment\\n dst_node = alloc_DES[des]\\n print (\\\"\\\\t Looking the path to id_node: %i\\\" % dst_node)\\n\\n path = list(nx.shortest_path(myDigraph, source=node_src, target=dst_node, weight='BW'))\\n actual_path_size = nx.shortest_path_length(myDigraph, source=node_src, target=dst_node, weight='BW')\\n\\n # Calculo do fluxo maximo no grafo desde 1 ate 6\\n # flow_value, flow_dict = list(nx.maximum_flow(myDigraph, _s=0, _t=6, capacity=\\\"BW\\\"))\\n # print(\\\"MAXFLOW VALUE: \\\", flow_value)\\n # print(\\\"MAXFLOW DICT: \\\", flow_dict)\\n\\n print (\\\"\\\\t\\\\t candidate to best path: \\\" + str(path) + \\\" Size = \\\" + str(actual_path_size))\\n\\n if actual_path_size < min_path_size:\\n min_path_size = actual_path_size\\n minPath = path\\n bestDES = des\\n\\n bestPath = [minPath]\\n bestDES = [des]\\n print (\\\"best path is: \\\", bestPath, \\\" with weigth \\\", min_path_size)\\n print \\\"---------------------------------------------------------\\\"\\n return bestPath, bestDES\",\n \"def greedy(self):\\n # for each node, find the incoming link with the highest score.\\n max_scores = {}\\n max_sources = {}\\n for source, target in self.iteredges():\\n score = self.get_score(source, target)\\n max_score = max_scores.get(target)\\n if max_score is None or score > max_score:\\n max_scores[target] = score\\n max_sources[target] = source\\n # then build a graph out of just these links.\\n succs = dict((n, []) for n in self)\\n for target, source in max_sources.items():\\n succs[source].append(target)\\n return Digraph(succs, self.get_score, self.get_label)\",\n \"def internal_link_density(self, node_list):\\n N = len(node_list)\\n n_links = self.number_internal_links(node_list)\\n if self.directed:\\n return float(n_links) / (N * (N - 1))\\n else:\\n return 2 * float(n_links) / (N * (N - 1))\",\n \"def __edgeRouter(self):\\r\\n def getEndpoint(nodeTuple, pointList, direction, isReversedEdge):\\r\\n \\\"\\\"\\\" Gets the nearest arrow endpoint. Handles edge reversal \\\"\\\"\\\"\\r\\n if((direction == 'start' and not isReversedEdge)\\r\\n or (direction == 'end' and isReversedEdge)): \\r\\n endNode = nodeTuple[0]\\r\\n if(isReversedEdge):\\r\\n ix = -2\\r\\n iy = -1\\r\\n else:\\r\\n ix = 0\\r\\n iy = 1\\r\\n else: \\r\\n endNode = nodeTuple[1]\\r\\n if(isReversedEdge):\\r\\n ix = 0\\r\\n iy = 1\\r\\n else:\\r\\n ix = -2 \\r\\n iy = -1 \\r\\n \\r\\n # Is it connected to a named port!?!\\r\\n if(endNode.isConnectedByNamedPort(edgeObject)):\\r\\n handler = endNode.getConnectedByNamedPortHandler(nodeTuple[2]) \\r\\n return dc.coords(handler)[:2]\\r\\n \\r\\n # Not a named port...\\r\\n return list(endNode.getClosestConnector2Point( endNode, pointList[ix], \\r\\n pointList[iy])) \\r\\n \\r\\n \\r\\n \\r\\n #todo: improve method for spline arrows + add comments + optimize?\\r\\n print '----------------Dummy Edge Routing-----------------'\\r\\n for dummyEdge in NodeWrapper.ID2LayerEdgeDict.keys():\\r\\n \\r\\n dummyList = NodeWrapper.ID2LayerEdgeDict[dummyEdge]\\r\\n dummyNode = dummyList[0]\\r\\n dummyChild = dummyNode.children.keys()[0]\\r\\n linkFlagList = dummyNode.children[dummyChild]\\r\\n \\r\\n # Real nodes at start/end of the edge\\r\\n edgeSourceNode = dummyNode.parents.keys()[0]\\r\\n edgeSourceNode = edgeSourceNode.getASGNode().graphObject_\\r\\n dummyNode = dummyList[-1]\\r\\n edgeTargetNode = dummyNode.children.keys()[0]\\r\\n #print 'Dummy edge number', dummyEdge,\\r\\n #print dummyList[0].parents.keys()[0].getName(), edgeTargetNode.getName()\\r\\n edgeTargetNode = edgeTargetNode.getASGNode().graphObject_\\r\\n nodeTuple = [edgeSourceNode, edgeTargetNode, None]\\r\\n \\r\\n # Some edges are internally reversed to break cycles, when drawing\\r\\n # this must be taken into account\\r\\n isReversedEdge = False\\r\\n edgesToRoute = []\\r\\n for linkNode, isReversed in linkFlagList:\\r\\n edgesToRoute.append(linkNode)\\r\\n if(isReversed):\\r\\n isReversedEdge = True\\r\\n \\r\\n # Get all the points the edge must pass through (sorted by layer order)\\r\\n dummyList.sort(lambda a, b: cmp(a.getLayer(), b.getLayer()))\\r\\n if(isReversedEdge):\\r\\n dummyList.reverse()\\r\\n sortedDummyRouteList = []\\r\\n for node in dummyList:\\r\\n sortedDummyRouteList += node.getEdgePosition()\\r\\n \\r\\n # Set the coordinates of the edge directly \\r\\n # This is complicated by the fact that AToM3 treats edges as two\\r\\n # segments that join poorly (for spline arrows)\\r\\n for edgeObject in edgesToRoute: \\r\\n dc = edgeObject.graphObject_.dc\\r\\n linkObj = edgeObject.graphObject_ \\r\\n tag = linkObj.tag\\r\\n \\r\\n if(isReversedEdge):\\r\\n inPoint = dc.coords( tag + \\\"2ndSeg0\\\" )[:2]\\r\\n outPoint = dc.coords( tag + \\\"1stSeg0\\\" )[:2]\\r\\n else:\\r\\n inPoint = dc.coords( tag + \\\"1stSeg0\\\" )[:2]\\r\\n outPoint = dc.coords( tag + \\\"2ndSeg0\\\" )[:2]\\r\\n \\r\\n #print 'Dummy route', sortedDummyRouteList\\r\\n numPoints = len(sortedDummyRouteList) / 2\\r\\n # Add 2 extra control points for odd case (to make splines nice)\\r\\n if(numPoints % 2 == 1):\\r\\n if(numPoints == 1):\\r\\n center = sortedDummyRouteList\\r\\n else:\\r\\n start = sortedDummyRouteList[:numPoints - 1]\\r\\n end = sortedDummyRouteList[numPoints + 1:]\\r\\n center = sortedDummyRouteList[numPoints - 1:numPoints + 1]\\r\\n \\r\\n if(not isReversedEdge):\\r\\n newMid1 = [center[0], center[1] - 20]\\r\\n newMid2 = [center[0], center[1] + 20]\\r\\n else:\\r\\n newMid2 = [center[0], center[1] - 20]\\r\\n newMid1 = [center[0], center[1] + 20]\\r\\n \\r\\n \\r\\n if(numPoints == 1):\\r\\n sortedDummyRouteList = newMid1 + center + newMid2 \\r\\n else:\\r\\n sortedDummyRouteList = start + newMid1 + center + newMid2 + end\\r\\n centerIndex = numPoints - 1 + 2\\r\\n \\r\\n # Add 1 extra control point for even case (to make splines nice)\\r\\n else:\\r\\n start = sortedDummyRouteList[:numPoints]\\r\\n end = sortedDummyRouteList[numPoints:]\\r\\n center = [start[-2] + (end[0] - start[-2]) / 2, \\r\\n start[-1] + (end[1] - start[-1]) / 2]\\r\\n sortedDummyRouteList = start + center + end \\r\\n centerIndex = numPoints\\r\\n \\r\\n # Now I know where the center is... so lets move the center object\\r\\n # Is the edge object a hyperlink?\\r\\n if(len(edgeObject.in_connections_ + edgeObject.out_connections_) > 2):\\r\\n fromObjs = []\\r\\n for semObj in edgeObject.in_connections_:\\r\\n fromObjs.append(semObj.graphObject_)\\r\\n toObjs = []\\r\\n for semObj in edgeObject.out_connections_:\\r\\n toObjs.append(semObj.graphObject_)\\r\\n optimizerHyperLink(dc, linkObj, fromObjs, toObjs, 0, 0, 0, center )\\r\\n continue\\r\\n \\r\\n else:\\r\\n linkObj.moveTo(* center)\\r\\n \\r\\n # Go through the 2 segments in the link\\r\\n nodeTuple[2] = edgeObject\\r\\n for connTuple in linkObj.connections:\\r\\n itemHandler = connTuple[0]\\r\\n direction = connTuple[1]\\r\\n \\r\\n if( direction ): \\r\\n inPoint = getEndpoint(nodeTuple, sortedDummyRouteList,\\r\\n 'start', isReversedEdge)\\r\\n\\r\\n segCoords = inPoint + sortedDummyRouteList[:centerIndex+2]\\r\\n else: \\r\\n outPoint = getEndpoint(nodeTuple, sortedDummyRouteList,\\r\\n 'end', isReversedEdge) \\r\\n segCoords = sortedDummyRouteList[centerIndex:] + outPoint\\r\\n segCoords = self.__reverseCoordList(segCoords)\\r\\n \\r\\n # Applies the changed coords to the canvas\\r\\n dc.coords( * [itemHandler] + segCoords ) \\r\\n \\r\\n # This may change the associated link drawings: \\r\\n # move them to the new point \\r\\n if( direction ):\\r\\n linkObj.updateDrawingsTo(inPoint[0], inPoint[1], itemHandler, \\r\\n segmentNumber=1)\\r\\n else:\\r\\n linkObj.updateDrawingsTo(outPoint[0], outPoint[1], itemHandler, \\r\\n segmentNumber=2)\",\n \"def _mout_edges(nodes):\\n n = nodes.shape[0]\\n edges = []\\n for i in range(0, n - 1):\\n for j in range(i, n):\\n if abs(nodes[i, 0] - nodes[j, 0]) > 1:\\n break\\n elif abs(nodes[i, 0] - nodes[j, 0]) == 1 and \\\\\\n abs(nodes[i, 1] - nodes[j, 1]) == 0:\\n edges.append([i, j])\\n elif abs(nodes[i, 1] - nodes[j, 1]) == 1:\\n edges.append([i, j])\\n return edges\",\n \"def naiveGlobalRouting(self):\\n for e_list in self.s2e.values():\\n for e in e_list:\\n slot_path = []\\n src_slot = self.v2s[e.src]\\n dst_slot = self.v2s[e.dst]\\n slot_path.append(src_slot)\\n\\n curr = src_slot\\n len_x = src_slot.getLenX()\\n len_y = src_slot.getLenY()\\n\\n # first go in X direction\\n x_diff = curr.getPositionX() - dst_slot.getPositionX()\\n if x_diff:\\n dir = 'LEFT' if x_diff > 0 else 'RIGHT'\\n for i in range(int(abs(x_diff/len_x))):\\n curr = self.slot_manager.createSlotForRouting(curr.getNeighborSlotName(dir))\\n slot_path.append(curr)\\n\\n y_diff = curr.getPositionY() - dst_slot.getPositionY()\\n if y_diff:\\n dir = 'DOWN' if y_diff > 0 else 'UP'\\n for i in range(int(abs(y_diff/len_y))):\\n curr = self.slot_manager.createSlotForRouting(curr.getNeighborSlotName(dir))\\n slot_path.append(curr)\\n \\n assert curr == dst_slot\\n \\n slot_path = slot_path[1:-1] # exclude the src and the dst\\n logging.info(f'{e.name}: {self.v2s[e.src].getName()} -> {self.v2s[e.dst].getName()} : ' + ' '.join(s.getName() for s in slot_path))\\n self.e_name2path[e.name] = slot_path\",\n \"def bandwidth_share(self, nodes_efficiency: Dict[str, float]) -> Dict[str, float]:\\n pass\",\n \"def run_dfs(self,s):\\n if self.verbose: print('entering run_dfs with s = ',s)\\n new_states = [self.succ(s,a) for a in self.actions(s)]\\n results = []\\n\\n for ns in new_states:\\n if self.verbose: print('considering new state = ',ns)\\n end = self.is_end(ns)\\n if end:\\n result = self.result(ns)\\n if result is not None:\\n results.append(result)\\n else:\\n results += self.run_dfs(ns)\\n return results\",\n \"def get_network_ratio(df, edges, initial_buffer=500):\\n\\n # intersection-based join\\n buff = edges.buffer(0.01) # to avoid floating point error\\n inp, res = buff.sindex.query_bulk(df.geometry, predicate=\\\"intersects\\\")\\n intersections = (\\n df.iloc[inp]\\n .reset_index(drop=True)\\n .intersection(buff.iloc[res].reset_index(drop=True))\\n )\\n mask = intersections.area > 0.0001\\n intersections = intersections[mask]\\n inp = inp[mask]\\n lengths = intersections.area\\n grouped = lengths.groupby(inp)\\n totals = grouped.sum()\\n ints_vect = []\\n for name, group in grouped:\\n ratios = group / totals.loc[name]\\n ints_vect.append({res[item[0]]: item[1] for item in ratios.iteritems()})\\n\\n edge_dicts = pd.Series(ints_vect, index=totals.index)\\n\\n # nearest neighbor join\\n nans = df.index.difference(edge_dicts.index)\\n buffered = df.iloc[nans].buffer(initial_buffer)\\n additional = []\\n for orig, geom in zip(df.iloc[nans].geometry, buffered.geometry):\\n query = edges.sindex.query(geom, predicate=\\\"intersects\\\")\\n b = initial_buffer\\n while query.size == 0:\\n query = edges.sindex.query(geom.buffer(b), predicate=\\\"intersects\\\")\\n b += initial_buffer\\n additional.append({edges.iloc[query].distance(orig).idxmin(): 1})\\n\\n additional = pd.Series(additional, index=nans)\\n ratios = pd.concat([edge_dicts, additional]).sort_index()\\n result = pd.DataFrame()\\n result[\\\"edgeID_keys\\\"] = ratios.apply(lambda d: list(d.keys()))\\n result[\\\"edgeID_values\\\"] = ratios.apply(lambda d: list(d.values()))\\n result.index = df.index\\n return result\",\n \"def sage_graph(self):\\n self.fe.load_cache()\\n edges = []\\n is_bipartite = self.variant.is_bipartite()\\n for X in self.L:\\n for Y in self.L:\\n a = self.op_norm(X, Y)\\n if not self.K.is_zero(a):\\n for c in self.K.unit_group:\\n d = a - c\\n if X != Y or c < d or is_bipartite:\\n edges.append(((X, c, False), (Y, d, is_bipartite)))\\n if X == Y and not is_bipartite:\\n break\\n return sage.all.Graph(edges)\",\n \"def construct_fast_graph_connection(coord_list, radie):\\n\\n connection_distance = []\\n connection = []\\n coord_list_tree = scipy.spatial.cKDTree(coord_list)\\n for j, data in enumerate(coord_list):\\n '''save nodes which are in range'''\\n connections_ckd = coord_list_tree.query_ball_point(data, radie)\\n for i in connections_ckd:\\n #only save upper half of the matrix\\n if i > j:\\n #save the connection\\n connection.append([j, i])\\n #save the relative distance of the nodes\\n connection_distance.append(np.hypot(coord_list[i,0]-data[0], coord_list[i,1]-data[1]))\\n\\n connection_distance = np.array(connection_distance)\\n connection = np.array(connection)\\n\\n\\n return connection, connection_distance\",\n \"def test_find_path_dfs():\\n g = Graph()\\n node_1 = Node({'A':['B','C']})\\n g.add(node_1)\\n node_2 = Node({'B':['C','D']})\\n g.add(node_2)\\n node_3 = Node({'C':['D']})\\n g.add(node_3)\\n node_4 = Node({'D':['C']})\\n g.add(node_4)\\n node_5 = Node({'E':['C']})\\n g.add(node_5)\\n\\n # zero path between node_1 and node_5\\n path_0 = g.find_path_dfs(node_1, node_5)\\n assert path_0 == None\\n\\n # only one path between node_5 and node_4\\n path_1 = g.find_path_dfs(node_5, node_4)\\n assert [ node.name for node in path_1 ] == [ node_5.name, node_3.name, node_4.name ]\\n\\n # three paths between node_1 and node_3, verify anyone of the three is returned\\n path_3 = g.find_path_dfs(node_1, node_3)\\n assert [ node.name for node in path_3 ] == [ node_1.name, node_2.name, node_3.name ] or \\\\\\n [ node.name for node in path_3 ] == [ node_1.name, node_2.name, node_4.name, node_3.name ] or \\\\\\n [ node.name for node in path_3 ] == [ node_1.name, node_3.name ]\",\n \"def trapezium_rule(f, m, x, a, b, n):\\n h = (b-a)/float(n)\\n s = 0.5*(f(m, x, a) + f(m, x, b))\\n for i in range(n):\\n s = s + f(m, x, a + i*h)\\n return h*s\",\n \"def compute_equal_flow_allocations(target_graph, K=3):\\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\\n flow_allocation_seed_number = 0xDEAD_BEEF\\n np.random.seed(flow_allocation_seed_number)\\n flows = []\\n for node in target_graph.nodes:\\n possible_destination_nodes = set(target_graph.nodes) - set([node])\\n [destination_node] = np.random.choice(list(possible_destination_nodes), 1, replace=False)\\n # shortest_paths = all_shortest_paths(target_graph, node, destination_node.item())\\n shortest_paths = sorted(nx.all_simple_paths(target_graph, node, destination_node.item(),\\n cutoff=3),\\n key=lambda p: len(p))\\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\\n the_flow = Flow( source_node = node\\n , destination_node = destination_node.item()\\n , flow_tx_rate = 10.0\\n , paths = k_shortest_paths\\n , splitting_ratio = [1/K]*K\\n )\\n flows.append(the_flow)\\n \\n return flow_allocation_seed_number, flows\",\n \"def get_urls(*params: str, num_of_links: int = 1) -> list:\\n urls = []\\n try:\\n for i in range(num_of_links):\\n url = \\\"https://finviz.com/screener.ashx?v=111\\\"\\n codes = ','.join(rts_codes[len(rts_codes)*(num_of_links - i - 1)//num_of_links:(len(rts_codes)*(num_of_links - i)//num_of_links)])\\n payload = {\\\"FT\\\": 2,\\\"f\\\": params,\\\"t\\\": codes}\\n req = requests.get(url, params=payload)\\n if len(req.url) > 2900:\\n urls = []\\n num_of_links += 1\\n urls = get_urls(*params, num_of_links=num_of_links)\\n else:\\n urls.append(req.url)\\n return (urls)\\n except Exception as e:\\n print (e)\\n return None\",\n \"def pair_frame(captured_file, frame_seq):\\n rid = 0\\n all_frame = {}\\n fs_relation = {} # frame_stream_relation, mapping from stream number to one or more rid\\n get_pairing = \\\"tshark -2 -r {} -R '' -Y 'frame.number > 0 && http.request' -T fields -e tcp.stream -e frame.number -e http.response_in\\\"\\n \\n # Run get_pairing command\\n pairs = run_command(get_pairing.format(captured_file), False)\\n\\n # Associate each request and response node with its frame number in a dict\\n for i in range(0, len(frame_seq)):\\n cur_node = frame_seq[i]\\n all_frame[cur_node.get_frame()] = cur_node\\n \\n all_stream = []\\n for p in pairs:\\n pl = p.decode('utf8').rstrip('\\\\n').split('\\\\t')\\n cur_sn = int(pl[0]) # current_stream_number\\n try:\\n fs_relation[cur_sn]\\n except KeyError:\\n fs_relation[cur_sn] = []\\n all_stream.append(cur_sn)\\n fs_relation[cur_sn].append(rid)\\n\\n req_fn = int(pl[1]) # request_frame\\n all_frame[req_fn].set_req()\\n all_frame[req_fn].set_rid(rid)\\n\\n try:\\n res_fn = int(pl[2]) # response_frame\\n all_frame[res_fn].set_res()\\n all_frame[res_fn].set_rid(rid)\\n except ValueError:\\n # Handle request without response here\\n pass\\n\\n rid += 1\\n\\n return frame_seq, fs_relation, all_stream\",\n \"def _split_forced(self, node):\\n # compute the split\\n _vec = 0\\n sorted_idxs = np.argsort(self.E[node.ids, _vec]).squeeze()\\n n = len(sorted_idxs) // 2\\n _lids = node.ids[sorted_idxs[:n]]\\n _rids = node.ids[sorted_idxs[n:]]\\n # compute the score of the new tubes only\\n _sl = self.get_tube_score(_lids)\\n _sr = self.get_tube_score(_rids)\\n # register the split\\n node.has_children = True\\n node.thresh = np.median(self.E[node.ids, _vec]) # arbitrary\\n # Note: median would not ensure equal size (because of duplicate values)\\n left = SpectralNode(_lids, _vec, score=_sl, name=node.name + \\\"0\\\")\\n right = SpectralNode(_rids, _vec, score=_sr, name=node.name + \\\"1\\\")\\n\\n return left, right\",\n \"def a_star_alg(self, p1: int, p2: int, max_level: int = 1000):\\r\\n \\r\\n # Create start and end node\\r\\n start_node = Node(None, p1, self.node_dict[p1])\\r\\n start_node.g = start_node.h = start_node.f = 0\\r\\n end_node = Node(None, p2, self.node_dict[p2])\\r\\n end_node.g = end_node.h = end_node.f = 0\\r\\n\\r\\n # Initialize both open and closed list\\r\\n open_list = []\\r\\n closed_list = []\\r\\n\\r\\n # Add the start node\\r\\n open_list.append(start_node)\\r\\n\\r\\n # Loop until you find the end\\r\\n level = 0\\r\\n while len(open_list) > 0 and level < max_level:\\r\\n level += 1\\r\\n\\r\\n # Get the current node (the node in open_list with the lowest cost)\\r\\n current_node = open_list[0]\\r\\n current_index = 0\\r\\n for index, item in enumerate(open_list):\\r\\n if item.f < current_node.f:\\r\\n current_node = item\\r\\n current_index = index\\r\\n\\r\\n # Pop current off open list, add to closed list\\r\\n open_list.pop(current_index)\\r\\n closed_list.append(current_node)\\r\\n\\r\\n # Found the goal\\r\\n if current_node == end_node:\\r\\n path = []\\r\\n distance = current_node.g\\r\\n current = current_node\\r\\n while current is not None:\\r\\n path.append(current.number)\\r\\n current = current.parent\\r\\n\\r\\n return path[::-1], distance # Return reversed path\\r\\n\\r\\n # Generate children\\r\\n children = []\\r\\n for new_number in self.road_tree[current_node.number]: # Adjacent nodes\\r\\n new_node = Node(current_node, new_number, self.node_dict[new_number])\\r\\n children.append(new_node)\\r\\n\\r\\n # Loop through children\\r\\n for child in children:\\r\\n append_to_open_list = False\\r\\n\\r\\n # Create the f, g, and h values\\r\\n child.g = current_node.g + self.road_dict[(current_node.number, child.number)]\\r\\n child.h = sqrt((child.x - end_node.x) ** 2 + (child.y - end_node.y) ** 2) / 200\\r\\n child.f = child.g + child.h\\r\\n\\r\\n # Child is already in the closed list\\r\\n closed_list, append_to_open_list = self.check_in_list(child, closed_list, append_to_open_list)\\r\\n\\r\\n # Child is already in the open list\\r\\n open_list, append_to_open_list = self.check_in_list(child, open_list, append_to_open_list)\\r\\n\\r\\n # Add the child to the open list\\r\\n if append_to_open_list:\\r\\n open_list.append(child)\\r\\n\\r\\n return [], 1e10\",\n \"def bfs(self, s):\\n g = Graph(attr={DIRECTED: True})\\n root = self.get_vertex(s)\\n root.attributes[DISCOVERED] = True\\n q = collections.deque()\\n adjacent_type = '+' if DIRECTED in self.attr and self.attr[\\n DIRECTED] else None\\n # Insert root node in graph and queue\\n g.add_vertex(root)\\n q.append(s)\\n\\n while (len(q) > 0):\\n v = q.popleft()\\n for e in self.get_adjacent_vertices_by_vertex(v, adjacent_type):\\n w = self.get_vertex(e)\\n if DISCOVERED not in w.attributes or w.attributes[\\n DISCOVERED] is False:\\n w.attributes[DISCOVERED] = True\\n q.append(w.id)\\n g.add_vertex(w)\\n g.add_edge(edge.Edge(v, e), True)\\n return g\",\n \"def _semiconnected_ramps(slope1=1., slope2=1.) -> cs.Network:\\n\\n class _Ramp(cs.Simulator):\\n \\\"\\\"\\\"Used in tests to mock a simulator\\\"\\\"\\\"\\n def __init__(self, slope: Fraction, step_size: Fraction):\\n self._step_size = step_size\\n self._x = Fraction(0)\\n self._slope = slope\\n\\n @property\\n def inputs(self):\\n return {'u': sdf.InputPort(float, 1)}\\n\\n @property\\n def outputs(self):\\n return {'y': sdf.OutputPort(float, 1)}\\n\\n def calculate(self, input_tokens):\\n self._x += self._slope * self._step_size\\n return {'y': [float(self._x)]}\\n\\n def construct_ramp1(step_size):\\n return _Ramp(slope1, step_size)\\n\\n def construct_ramp2(step_size):\\n return _Ramp(slope2, step_size)\\n\\n slaves = {'Ramp1': construct_ramp1, 'Ramp2': construct_ramp2}\\n\\n connections = {\\n cs.Dst('Ramp1', 'u'): cs.Src('Ramp2', 'y'),\\n cs.Dst('Ramp2', 'u'): cs.Src('Ramp1', 'y'),\\n }\\n return slaves, connections\",\n \"def find_all_cycles(s,graph):\\n\\n grph = u.edge_to_list_dict(graph)\\n node_cnt = len(grph)\\n k = z.Int(\\\"k\\\")\\n syms = [z.Int('node%s'%i) for i in range(node_cnt)]\\n\\n # s.add(syms[0] == 0) # start node is a 0\\n s.add(k < node_cnt)\\n s.add(k > 1)\\n\\n o = z.Optimize()\\n\\n # for source, sinks in sgraph.s_adj_list():\\n for i in range(node_cnt):\\n s.add(syms[i] >= 0)\\n s.add(syms[i] <= k)\\n s.add(z.Or([syms[j] == ((syms[i] + 1) % k) for j in grph[i]]) == (syms[i] == 0))\\n\\n\\n r = []\\n m = []\\n\\n # o.minimize(z.Sum([syms[i] for i in range(node_cnt)]))\\n s.add(z.Product([syms[i] for i in range(node_cnt)]) == 0)\\n done = False\\n while not done:\\n if s.check() == z.sat:\\n m = s.model()\\n r.append(m)\\n s.add(k != m[k])\\n else:\\n done = True\\n\\n return r\",\n \"def calc_lp(self, demands: Demand, routing: Routing) -> float:\\n epsilon = self.epsilon\\n\\n # Create the linear solver with the GLOP backend.\\n solver = pywraplp.Solver('flow_utilisation_lp',\\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\\n\\n ## VARIABLES\\n # Flow variables, the amount of flow along each edge\\n # stored as a list flow_variables[ith_flow][jth_edge]\\n flow_variables = []\\n for i in range(len(self.commodities)):\\n flow_variable_edges = []\\n for j in range(len(self.edges)):\\n flow_variable_edges.append(\\n solver.NumVar(0, solver.infinity(), '({},{})'.format(i, j)))\\n flow_variables.append(flow_variable_edges)\\n\\n ## CONSTRAINTS\\n # Flow from source constraint (net flow must equal demand)\\n conservation_source_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # create constraint\\n constraint_i = solver.Constraint(demands[i] - epsilon,\\n demands[i] + epsilon,\\n '(source,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[0])]:\\n # out flow is positive\\n constraint_i.SetCoefficient(flow_variables[i][edge_index], 1)\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[0])]:\\n # in flow is negative\\n constraint_i.SetCoefficient(flow_variables[i][edge_index], -1)\\n conservation_source_constraints.append(constraint_i)\\n\\n # Flow to sink constraint (in flow must equal demand, out must be zero)\\n conservation_sink_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # create in flow constraint\\n constraint_i_in = solver.Constraint(-demands[i] - epsilon,\\n -demands[i] + epsilon,\\n '(sink_in,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[1])]:\\n # in flow is negative\\n constraint_i_in.SetCoefficient(flow_variables[i][edge_index],\\n -1)\\n conservation_sink_constraints.append(constraint_i_in)\\n\\n constraint_i_out = solver.Constraint(0, 0,\\n '(sink_out,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[1])]:\\n # out flow is positive\\n constraint_i_out.SetCoefficient(flow_variables[i][edge_index],\\n 1)\\n conservation_sink_constraints.append(constraint_i_out)\\n\\n # Flow at transit node constraint (net flow must be zero)\\n conservation_transit_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.graph.number_of_nodes()):\\n if j != commodity[0] and j != commodity[1]:\\n # create constraint\\n constraint_j = solver.Constraint(-epsilon, +epsilon,\\n '(transit,{},{})'.format(i,\\n j))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(j)]:\\n # out flow is positive\\n constraint_j.SetCoefficient(\\n flow_variables[i][edge_index],\\n 1)\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(j)]:\\n # in flow is negative\\n constraint_j.SetCoefficient(\\n flow_variables[i][edge_index],\\n -1)\\n constraints_flow_i.append(constraint_j)\\n conservation_transit_constraints.append(constraints_flow_i)\\n\\n # Flow splitting at transit constraints (edge flow must be correct split of\\n # in flow)\\n splitting_ratio_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.graph.number_of_nodes()):\\n # Sink has not such constraint and we handle source differently\\n if j != commodity[1] and j != commodity[0]:\\n in_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(j)]\\n out_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(j)]\\n\\n # separate constraint for split of each out_edge taking into\\n # account all in_edges\\n for out_edge_index in out_edges:\\n # create constraint\\n constraint_edge = \\\\\\n solver.Constraint(-epsilon, +epsilon,\\n '(split,{},{},{})'.format(\\n i, j,\\n out_edge_index))\\n split_ratio = routing[i][out_edge_index]\\n # flow on out edge\\n constraint_edge.SetCoefficient(\\n flow_variables[i][out_edge_index], 1)\\n for in_edge_index in in_edges:\\n # should equal sum of flow on all in edges scaled by\\n # split ratio\\n constraint_edge.SetCoefficient(\\n flow_variables[i][in_edge_index],\\n -1 * split_ratio)\\n constraints_flow_i.append(constraint_edge)\\n splitting_ratio_constraints.append(constraints_flow_i)\\n\\n # Flow splitting at source constraints (edge flow must be correct split of\\n # in flow + demand)\\n source_splitting_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n in_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[0])]\\n out_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[0])]\\n for out_edge_index in out_edges:\\n # create constraint\\n split_ratio = routing[i][out_edge_index]\\n split_demand = split_ratio * demands[i]\\n constraint_edge = \\\\\\n solver.Constraint(split_demand - epsilon,\\n split_demand + epsilon,\\n '(split,{},{},{})'.format(i, j,\\n out_edge_index))\\n # flow on out edge\\n constraint_edge.SetCoefficient(\\n flow_variables[i][out_edge_index], 1)\\n for in_edge_index in in_edges:\\n # should equal sum of flow on all in edges scaled by split ratio\\n constraint_edge.SetCoefficient(\\n flow_variables[i][in_edge_index],\\n -1 * split_ratio)\\n constraints_flow_i.append(constraint_edge)\\n source_splitting_constraints.append(constraints_flow_i)\\n\\n solver.Solve()\\n\\n result_status = solver.Solve()\\n\\n utilisation = np.zeros(\\n (len(self.commodities), self.graph.number_of_edges()))\\n # # extract the actual routing. Useful for debugging, maybe use to bootstrap\\n # assignment = np.zeros(\\n # (len(self.commodities), self.graph.number_of_edges()))\\n\\n # if routing is really that bad, just bail and give a sad result\\n if result_status == solver.NOT_SOLVED or result_status == solver.INFEASIBLE:\\n return 1.0\\n\\n for i in range(len(self.commodities)):\\n for j in range(self.graph.number_of_edges()):\\n utilisation[i][j] = flow_variables[i][j].solution_value() / \\\\\\n self.edges[j][2]['weight']\\n # assignment[i][j] = flow_variables[i][j].solution_value()\\n\\n return np.max(np.sum(utilisation, axis=0))\",\n \"def bfs(self) -> dict:\\n distances_graph = {}\\n\\n # BFS from middle to the robot start point\\n start = self.center\\n search = self.start\\n\\n distances_graph[start] = 0\\n queue = collections.deque([start])\\n\\n while True:\\n # Get next node\\n node = queue.pop()\\n\\n if node == search:\\n # If this is the one we need, search no more\\n break\\n\\n for neighbor in self.graph[node]:\\n if neighbor not in distances_graph:\\n # If distance to neighbor hasn't been calculated, calculate it\\n queue.appendleft(neighbor)\\n distances_graph[neighbor] = distances_graph[node] + 1\\n\\n return distances_graph\",\n \"def setup_nodes(server_node, road_node, road_segment_point):\\n\\n # Create working server node data subset excluding unneeded fields\\n snode = [{'id': i,\\n 'shapeid': item['shapeid'],\\n 'x': float(item['x']),\\n 'y': float(item['y']),\\n 'nearest_pt': None,\\n 'nearest_pt_sl_dist': float(\\\"inf\\\"),\\n 'color_num': (int(item['shapeid']) + CM_OFFSET) % NUM_COLORS}\\n for i, item in enumerate(server_node)]\\n\\n # Create working road node data subset excluding unneeded fields\\n # (note: road nodes consist of junctions and road ends)\\n rnode = []\\n prev_coord = []\\n for i, item in enumerate(road_node):\\n if [item['x'], item['y']] not in prev_coord: # exclude duplicates\\n rnode.append({'id': i,\\n 'shapeid': item['shapeid'],\\n 'x': float(item['x']),\\n 'y': float(item['y']),\\n 'best_server': None,\\n 'color_num': GREY})\\n prev_coord.append([item['x'], item['y']])\\n\\n # Create working road point data subset excluding unneeded fields\\n rpoint = []\\n point = 0\\n for i in range(len(road_segment_point)):\\n id = road_segment_point[i]['shapeid']\\n rpoint.append({'id': i,\\n 'shapeid': id,\\n 'point': point,\\n 'x': float(road_segment_point[i]['x']),\\n 'y': float(road_segment_point[i]['y']),\\n 'lowest_cost': float(\\\"inf\\\"),\\n 'best_server': None,\\n 'color_num': GREY})\\n if i < len(road_segment_point) - 1:\\n id_next = road_segment_point[i + 1]['shapeid']\\n if id == id_next:\\n point += 1\\n else:\\n point = 0\\n\\n # Convert adjacent road segment endpoints to lines (x1, y1) to (x2, y2)\\n rseg = []\\n line = 0\\n seg = 0\\n for i in range(len(rpoint[:-1])):\\n id = rpoint[i]['shapeid']\\n id_next = rpoint[i + 1]['shapeid']\\n if id == id_next:\\n rseg.append({'id': line,\\n 'shapeid': id,\\n 'segment': seg,\\n 'point1': rpoint[i]['id'],\\n 'x1': float(rpoint[i]['x']),\\n 'y1': float(rpoint[i]['y']),\\n 'point2': rpoint[i + 1]['id'],\\n 'x2': float(rpoint[i + 1]['x']),\\n 'y2': float(rpoint[i + 1]['y']),\\n 'best_server': None,\\n 'color_num': GREY})\\n line += 1\\n seg += 1\\n else:\\n seg = 0\\n\\n return snode, rnode, rpoint, rseg\",\n \"def routes(self) -> List[Tuple[int, bytes]]:\\n raise NotImplementedError() # pragma: no cover\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6946733","0.5595293","0.55341357","0.5483804","0.54689676","0.546619","0.53488106","0.5347624","0.53359586","0.5324602","0.531136","0.527324","0.52406126","0.52348506","0.52295214","0.5226473","0.5220885","0.52176976","0.5189963","0.5180724","0.5178925","0.5175554","0.5173613","0.51691705","0.5143392","0.51332587","0.5121009","0.5105846","0.51043695","0.5100887","0.509861","0.5075307","0.50644517","0.50435597","0.50418633","0.50370014","0.5035648","0.50303215","0.50255024","0.50134647","0.5007576","0.5003768","0.5000623","0.49965784","0.49886715","0.49853468","0.49788836","0.4975265","0.49747163","0.49734658","0.49733436","0.49708298","0.4968786","0.4962878","0.495524","0.49549156","0.4940138","0.49282336","0.49142206","0.49078572","0.4903702","0.49035385","0.48848093","0.4876706","0.48625693","0.48617828","0.4860584","0.4859201","0.4855706","0.48551083","0.4850922","0.48384398","0.48380518","0.48359606","0.48345026","0.48258856","0.48212236","0.4820678","0.4816889","0.48164463","0.48142397","0.48058394","0.4805581","0.4805519","0.48032212","0.4800917","0.47997996","0.47960877","0.47942194","0.47858524","0.4783655","0.47801873","0.47796226","0.47791833","0.47757685","0.47727418","0.47726148","0.4764818","0.47647363"],"string":"[\n \"0.6946733\",\n \"0.5595293\",\n \"0.55341357\",\n \"0.5483804\",\n \"0.54689676\",\n \"0.546619\",\n \"0.53488106\",\n \"0.5347624\",\n \"0.53359586\",\n \"0.5324602\",\n \"0.531136\",\n \"0.527324\",\n \"0.52406126\",\n \"0.52348506\",\n \"0.52295214\",\n \"0.5226473\",\n \"0.5220885\",\n \"0.52176976\",\n \"0.5189963\",\n \"0.5180724\",\n \"0.5178925\",\n \"0.5175554\",\n \"0.5173613\",\n \"0.51691705\",\n \"0.5143392\",\n \"0.51332587\",\n \"0.5121009\",\n \"0.5105846\",\n \"0.51043695\",\n \"0.5100887\",\n \"0.509861\",\n \"0.5075307\",\n \"0.50644517\",\n \"0.50435597\",\n \"0.50418633\",\n \"0.50370014\",\n \"0.5035648\",\n \"0.50303215\",\n \"0.50255024\",\n \"0.50134647\",\n \"0.5007576\",\n \"0.5003768\",\n \"0.5000623\",\n \"0.49965784\",\n \"0.49886715\",\n \"0.49853468\",\n \"0.49788836\",\n \"0.4975265\",\n \"0.49747163\",\n \"0.49734658\",\n \"0.49733436\",\n \"0.49708298\",\n \"0.4968786\",\n \"0.4962878\",\n \"0.495524\",\n \"0.49549156\",\n \"0.4940138\",\n \"0.49282336\",\n \"0.49142206\",\n \"0.49078572\",\n \"0.4903702\",\n \"0.49035385\",\n \"0.48848093\",\n \"0.4876706\",\n \"0.48625693\",\n \"0.48617828\",\n \"0.4860584\",\n \"0.4859201\",\n \"0.4855706\",\n \"0.48551083\",\n \"0.4850922\",\n \"0.48384398\",\n \"0.48380518\",\n \"0.48359606\",\n \"0.48345026\",\n \"0.48258856\",\n \"0.48212236\",\n \"0.4820678\",\n \"0.4816889\",\n \"0.48164463\",\n \"0.48142397\",\n \"0.48058394\",\n \"0.4805581\",\n \"0.4805519\",\n \"0.48032212\",\n \"0.4800917\",\n \"0.47997996\",\n \"0.47960877\",\n \"0.47942194\",\n \"0.47858524\",\n \"0.4783655\",\n \"0.47801873\",\n \"0.47796226\",\n \"0.47791833\",\n \"0.47757685\",\n \"0.47727418\",\n \"0.47726148\",\n \"0.4764818\",\n \"0.47647363\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7221145"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":24594,"cells":{"query":{"kind":"string","value":"View function for home page of site."},"document":{"kind":"string","value":"def summary(request):\n\n # Generate counts of some of the main objects\n num_courses = models.Course.objects.all().count()\n num_quizzes = models.Quiz.objects.all().count()\n num_questions = models.Question.objects.count()\n num_students = models.User.objects.count()\n num_visits = request.session.get('num_visits', 1)\n request.session['num_visits'] = num_visits + 1\n\n context = {\n 'num_courses': num_courses,\n 'num_quizzes': num_quizzes,\n 'num_questions': num_questions,\n 'num_students': num_students,\n 'num_visits': num_visits,\n }\n\n return Response(context)"},"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 home(request):\n\treturn render(request, \"compta/home.html\")","def home_page(request):\r\n return render(request, 'ez_main/home_page.html')","def home(request):\r\n return render(request, 'home.html')","def homepage(request):\n\treturn render(request, 'core/homepage.html')","def homepage(request):\n return render_to_response('h1ds_core/homepage.html', \n context_instance=RequestContext(request))","def home(request):\n return render_template('core/home.html')","def home(request):\n assert isinstance(request, HttpRequest)\n return render(\n request,\n 'AscensionESports_Baseline/index.html',\n {\n 'background': getSiteBackground(),\n 'color': getSiteColor(),\n 'title':'Home Page',\n 'year':datetime.now().year,\n }\n )","def home():\n\n return render_template('home_page.html')","def home(request):\n return render(request, 'base/home.html')","def home_page(request):\n return render(request, 'home.html')","def home():\n\n return render_template(\"home.html\")","def home(request):\n return render_to_response('home.html', {}, RequestContext(request))","def homepage():\n return render_template('home/index.html', \n title=\"Bem vindo!\")","def home():\n\n\treturn render_template('index.html', title='Home Page',\n\t\t\t\t\t\t year=datetime.now().year)","def home():\n\n\treturn render_template('solai.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def homepage():\n return render_template('home/index.html', title=\"Home\")","def home():\n return render_template('homepage.html')","def home():\n return render_template(\"home.html\")","def home():\n return render_template(\"home.html\")","def home():\n return render_template('home.html', title=\"Home\")","def homepage():\n return render_template(\"home/index.html\")","def home():\n return render_template(\n 'home.html',\n title='Home Page',\n year=datetime.now().year,\n )","def homepage():\n return render_template('home/index.html', title=\"Welcome\")","def homepage():\n return render_template('home/index.html', title=\"Welcome\")","def homepage():\n return render_template(\"home/index.html\", title=\"Welcome\")","def home(request):\n # Test Comment\n assert isinstance(request, HttpRequest)\n return render(\n request,\n 'index.html',\n context_instance=RequestContext(request,\n {\n 'title': 'Home Page',\n 'year': datetime.now().year,\n })\n )","def home(request):\n return render(request, 'home/index.html')","def home():\r\n return render_template(\r\n 'index.html',\r\n title='Home Page',\r\n year=datetime.now().year,\r\n )","def homepage(request):\n \n return render(request, 'homepage.html')","def home(request):\n return render_to_response('index.html')","def home(request):\n\n context = {\n\n }\n\n return render(request, 'hydraviewer/home.html', context)","def homepage():\n\treturn render_template(\"home/a_homepage.html\", title=\"Welcome\")","def home(request):\n if request.user.is_authenticated():\n return HttpResponseRedirect('logged-in')\n else:\n home_view = 1\n return render_to_response('content/home.html', {'version': version, \"home_view\":home_view},\n RequestContext(request))","def homepage():\n\n return render_template('rosemead_homepage.html')","def render_home():\r\n\treturn render_template(\"index.html\")","def get_home():\n return render_template(\"home.html\")","def home(request):\n context = {}\n\n return render(request, 'trailyzer/home.html', context)","def index():\r\n return render_template('home.html')","def home_page():\n\n return render_template('index.html')","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year\n )","def home():\n\n return render_template('index.html')","def home(request): \n return render_to_response('index.html', locals(), context_instance = RequestContext(request))","def homepage():\n return render_template('homepage.html')","def index(request):\n return render(request, 'home.html')","def home():\n return render_template('index.html')","def home():\n return render_template('index.html')","def home():\n return render_template('index.html')","def home():\n return render_template('index.html')","def home():\n return render_template('index.html')","def home():\n return render_template('index.html')","def home():\n return render_template(\n 'index.html'\n )","def home(request):\n\n return render(request,'index.html',{})","def home(request):\n assert isinstance(request, HttpRequest)\n return render(\n request,\n 'app/index.html',\n context_instance = RequestContext(request,\n {\n 'title':'Home Page',\n 'year':datetime.now().year,\n })\n )","def home() -> Any:\n return home_page()","def home():\n return render_template(\n 'index.html',\n title='Sairam sai baba',\n year=datetime.now().year,\n )","def home(self, *args, **kwargs):\n pass","def home(request):\r\n assert isinstance(request, HttpRequest)\r\n return render(\r\n request,\r\n 'app/index.html',\r\n {\r\n 'title':'Home Page',\r\n 'year':datetime.now().year,\r\n }\r\n )","def home():\n return render_template(\"index.html\")","def home():\n return render_template(\"index.html\")","def home():\n return render_template(\"index.html\")","def home():\n return render_template(\"index.html\")","def home_page() -> str:\r\n return render_template(\"home.html\")","def home():\n payload = manager.get_payload()\n return render_template('index.html', payload=payload)","def home(request):\n\n return render(request,'KIT_test/home.html')","def home(request):\n assert isinstance(request, HttpRequest)\n return render(\n request,\n 'app/index.html',\n {\n 'title':'Home Page',\n 'year':datetime.now().year,\n }\n )","def home(request):\n assert isinstance(request, HttpRequest)\n return render(\n request,\n 'app/index.html',\n {\n 'title':'Home Page',\n 'year':datetime.now().year,\n }\n )","def index():\n\n return render_template('home.html')","def index(self):\n\n return render_template(\n 'home_page/index.html',\n **locals()\n )","def index():\n return render_template('home.html')","def feature_view_home(request):\n return render(request, 'SNP_Feature_View/feature_view_home.html')","def home():\n return render_template('main.html')","def home(request):\r\n assert isinstance(request, HttpRequest)\r\n return render(\r\n request,\r\n 'app/index.html',\r\n context = \r\n {\r\n 'LastProject': Projet.objects.all().last(),\r\n 'LastEvent': Atelier.objects.all().last(),\r\n 'LastMachine':Machine.objects.all().last(),\r\n 'LastArticle':Article.objects.all().order_by('-id')[:3],\r\n 'title':_('Home Page'),\r\n 'year':datetime.now().year,\r\n }\r\n )","def home(request):\n\n\n template = 'index.html'\n return render(request,template)","def home():\n\n # sets the page to load depending on the type of user\n # if none specified the login screen will be displayed\n pageName = ''\n userType = session.get('UserType', None)\n if userType == None:\n pageName = 'anonHome.jade'\n elif userType == 'Seeker':\n pageName = 'indexJob.jade'\n elif userType == 'Manager':\n pageName = 'indexManager.jade'\n\n frogHop = url_for('static', filename='loop frog.gif')\n uName = session.get('UserName', 'Unknown') # load a default value if retrieval fails\n return render_template(\n pageName,\n title='Home',\n name=uName,\n getFrog=frogHop,\n year=datetime.now().year,\n )","def index():\n return render_template(\"home.html\")"],"string":"[\n \"def home(request):\\n\\treturn render(request, \\\"compta/home.html\\\")\",\n \"def home_page(request):\\r\\n return render(request, 'ez_main/home_page.html')\",\n \"def home(request):\\r\\n return render(request, 'home.html')\",\n \"def homepage(request):\\n\\treturn render(request, 'core/homepage.html')\",\n \"def homepage(request):\\n return render_to_response('h1ds_core/homepage.html', \\n context_instance=RequestContext(request))\",\n \"def home(request):\\n return render_template('core/home.html')\",\n \"def home(request):\\n assert isinstance(request, HttpRequest)\\n return render(\\n request,\\n 'AscensionESports_Baseline/index.html',\\n {\\n 'background': getSiteBackground(),\\n 'color': getSiteColor(),\\n 'title':'Home Page',\\n 'year':datetime.now().year,\\n }\\n )\",\n \"def home():\\n\\n return render_template('home_page.html')\",\n \"def home(request):\\n return render(request, 'base/home.html')\",\n \"def home_page(request):\\n return render(request, 'home.html')\",\n \"def home():\\n\\n return render_template(\\\"home.html\\\")\",\n \"def home(request):\\n return render_to_response('home.html', {}, RequestContext(request))\",\n \"def homepage():\\n return render_template('home/index.html', \\n title=\\\"Bem vindo!\\\")\",\n \"def home():\\n\\n\\treturn render_template('index.html', title='Home Page',\\n\\t\\t\\t\\t\\t\\t year=datetime.now().year)\",\n \"def home():\\n\\n\\treturn render_template('solai.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def homepage():\\n return render_template('home/index.html', title=\\\"Home\\\")\",\n \"def home():\\n return render_template('homepage.html')\",\n \"def home():\\n return render_template(\\\"home.html\\\")\",\n \"def home():\\n return render_template(\\\"home.html\\\")\",\n \"def home():\\n return render_template('home.html', title=\\\"Home\\\")\",\n \"def homepage():\\n return render_template(\\\"home/index.html\\\")\",\n \"def home():\\n return render_template(\\n 'home.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def homepage():\\n return render_template('home/index.html', title=\\\"Welcome\\\")\",\n \"def homepage():\\n return render_template('home/index.html', title=\\\"Welcome\\\")\",\n \"def homepage():\\n return render_template(\\\"home/index.html\\\", title=\\\"Welcome\\\")\",\n \"def home(request):\\n # Test Comment\\n assert isinstance(request, HttpRequest)\\n return render(\\n request,\\n 'index.html',\\n context_instance=RequestContext(request,\\n {\\n 'title': 'Home Page',\\n 'year': datetime.now().year,\\n })\\n )\",\n \"def home(request):\\n return render(request, 'home/index.html')\",\n \"def home():\\r\\n return render_template(\\r\\n 'index.html',\\r\\n title='Home Page',\\r\\n year=datetime.now().year,\\r\\n )\",\n \"def homepage(request):\\n \\n return render(request, 'homepage.html')\",\n \"def home(request):\\n return render_to_response('index.html')\",\n \"def home(request):\\n\\n context = {\\n\\n }\\n\\n return render(request, 'hydraviewer/home.html', context)\",\n \"def homepage():\\n\\treturn render_template(\\\"home/a_homepage.html\\\", title=\\\"Welcome\\\")\",\n \"def home(request):\\n if request.user.is_authenticated():\\n return HttpResponseRedirect('logged-in')\\n else:\\n home_view = 1\\n return render_to_response('content/home.html', {'version': version, \\\"home_view\\\":home_view},\\n RequestContext(request))\",\n \"def homepage():\\n\\n return render_template('rosemead_homepage.html')\",\n \"def render_home():\\r\\n\\treturn render_template(\\\"index.html\\\")\",\n \"def get_home():\\n return render_template(\\\"home.html\\\")\",\n \"def home(request):\\n context = {}\\n\\n return render(request, 'trailyzer/home.html', context)\",\n \"def index():\\r\\n return render_template('home.html')\",\n \"def home_page():\\n\\n return render_template('index.html')\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year\\n )\",\n \"def home():\\n\\n return render_template('index.html')\",\n \"def home(request): \\n return render_to_response('index.html', locals(), context_instance = RequestContext(request))\",\n \"def homepage():\\n return render_template('homepage.html')\",\n \"def index(request):\\n return render(request, 'home.html')\",\n \"def home():\\n return render_template('index.html')\",\n \"def home():\\n return render_template('index.html')\",\n \"def home():\\n return render_template('index.html')\",\n \"def home():\\n return render_template('index.html')\",\n \"def home():\\n return render_template('index.html')\",\n \"def home():\\n return render_template('index.html')\",\n \"def home():\\n return render_template(\\n 'index.html'\\n )\",\n \"def home(request):\\n\\n return render(request,'index.html',{})\",\n \"def home(request):\\n assert isinstance(request, HttpRequest)\\n return render(\\n request,\\n 'app/index.html',\\n context_instance = RequestContext(request,\\n {\\n 'title':'Home Page',\\n 'year':datetime.now().year,\\n })\\n )\",\n \"def home() -> Any:\\n return home_page()\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Sairam sai baba',\\n year=datetime.now().year,\\n )\",\n \"def home(self, *args, **kwargs):\\n pass\",\n \"def home(request):\\r\\n assert isinstance(request, HttpRequest)\\r\\n return render(\\r\\n request,\\r\\n 'app/index.html',\\r\\n {\\r\\n 'title':'Home Page',\\r\\n 'year':datetime.now().year,\\r\\n }\\r\\n )\",\n \"def home():\\n return render_template(\\\"index.html\\\")\",\n \"def home():\\n return render_template(\\\"index.html\\\")\",\n \"def home():\\n return render_template(\\\"index.html\\\")\",\n \"def home():\\n return render_template(\\\"index.html\\\")\",\n \"def home_page() -> str:\\r\\n return render_template(\\\"home.html\\\")\",\n \"def home():\\n payload = manager.get_payload()\\n return render_template('index.html', payload=payload)\",\n \"def home(request):\\n\\n return render(request,'KIT_test/home.html')\",\n \"def home(request):\\n assert isinstance(request, HttpRequest)\\n return render(\\n request,\\n 'app/index.html',\\n {\\n 'title':'Home Page',\\n 'year':datetime.now().year,\\n }\\n )\",\n \"def home(request):\\n assert isinstance(request, HttpRequest)\\n return render(\\n request,\\n 'app/index.html',\\n {\\n 'title':'Home Page',\\n 'year':datetime.now().year,\\n }\\n )\",\n \"def index():\\n\\n return render_template('home.html')\",\n \"def index(self):\\n\\n return render_template(\\n 'home_page/index.html',\\n **locals()\\n )\",\n \"def index():\\n return render_template('home.html')\",\n \"def feature_view_home(request):\\n return render(request, 'SNP_Feature_View/feature_view_home.html')\",\n \"def home():\\n return render_template('main.html')\",\n \"def home(request):\\r\\n assert isinstance(request, HttpRequest)\\r\\n return render(\\r\\n request,\\r\\n 'app/index.html',\\r\\n context = \\r\\n {\\r\\n 'LastProject': Projet.objects.all().last(),\\r\\n 'LastEvent': Atelier.objects.all().last(),\\r\\n 'LastMachine':Machine.objects.all().last(),\\r\\n 'LastArticle':Article.objects.all().order_by('-id')[:3],\\r\\n 'title':_('Home Page'),\\r\\n 'year':datetime.now().year,\\r\\n }\\r\\n )\",\n \"def home(request):\\n\\n\\n template = 'index.html'\\n return render(request,template)\",\n \"def home():\\n\\n # sets the page to load depending on the type of user\\n # if none specified the login screen will be displayed\\n pageName = ''\\n userType = session.get('UserType', None)\\n if userType == None:\\n pageName = 'anonHome.jade'\\n elif userType == 'Seeker':\\n pageName = 'indexJob.jade'\\n elif userType == 'Manager':\\n pageName = 'indexManager.jade'\\n\\n frogHop = url_for('static', filename='loop frog.gif')\\n uName = session.get('UserName', 'Unknown') # load a default value if retrieval fails\\n return render_template(\\n pageName,\\n title='Home',\\n name=uName,\\n getFrog=frogHop,\\n year=datetime.now().year,\\n )\",\n \"def index():\\n return render_template(\\\"home.html\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8493426","0.84268916","0.83415145","0.83306193","0.82976943","0.8295291","0.8276345","0.82545686","0.82155704","0.8132563","0.81246215","0.81224865","0.8121264","0.81049734","0.8098485","0.80935514","0.80935514","0.80935514","0.80935514","0.80935514","0.80935514","0.80935514","0.80935514","0.80935514","0.80935514","0.80935514","0.80935514","0.80935514","0.80935514","0.80935514","0.80935514","0.8079169","0.8077959","0.8062072","0.8062072","0.80510217","0.8038403","0.8037464","0.80228305","0.80228305","0.80228037","0.80155706","0.8012777","0.79984844","0.79943514","0.79930955","0.79915744","0.79835373","0.79439735","0.79235816","0.79182655","0.7918013","0.7894499","0.78879595","0.7887042","0.78837377","0.78837377","0.78837377","0.78837377","0.78837377","0.78837377","0.78837377","0.78837377","0.78837377","0.78837377","0.7865865","0.78647953","0.78617305","0.7828202","0.7802333","0.77971953","0.77971953","0.77971953","0.77971953","0.77971953","0.77971953","0.7791782","0.7786945","0.7784728","0.778366","0.77768356","0.77757293","0.7772452","0.77658075","0.77658075","0.77658075","0.77658075","0.7764756","0.7750751","0.77477163","0.7730367","0.7730367","0.7722212","0.77180296","0.76961213","0.7680976","0.76797205","0.76776814","0.76760346","0.76758707","0.7674136"],"string":"[\n \"0.8493426\",\n \"0.84268916\",\n \"0.83415145\",\n \"0.83306193\",\n \"0.82976943\",\n \"0.8295291\",\n \"0.8276345\",\n \"0.82545686\",\n \"0.82155704\",\n \"0.8132563\",\n \"0.81246215\",\n \"0.81224865\",\n \"0.8121264\",\n \"0.81049734\",\n \"0.8098485\",\n \"0.80935514\",\n \"0.80935514\",\n \"0.80935514\",\n \"0.80935514\",\n \"0.80935514\",\n \"0.80935514\",\n \"0.80935514\",\n \"0.80935514\",\n \"0.80935514\",\n \"0.80935514\",\n \"0.80935514\",\n \"0.80935514\",\n \"0.80935514\",\n \"0.80935514\",\n \"0.80935514\",\n \"0.80935514\",\n \"0.8079169\",\n \"0.8077959\",\n \"0.8062072\",\n \"0.8062072\",\n \"0.80510217\",\n \"0.8038403\",\n \"0.8037464\",\n \"0.80228305\",\n \"0.80228305\",\n \"0.80228037\",\n \"0.80155706\",\n \"0.8012777\",\n \"0.79984844\",\n \"0.79943514\",\n \"0.79930955\",\n \"0.79915744\",\n \"0.79835373\",\n \"0.79439735\",\n \"0.79235816\",\n \"0.79182655\",\n \"0.7918013\",\n \"0.7894499\",\n \"0.78879595\",\n \"0.7887042\",\n \"0.78837377\",\n \"0.78837377\",\n \"0.78837377\",\n \"0.78837377\",\n \"0.78837377\",\n \"0.78837377\",\n \"0.78837377\",\n \"0.78837377\",\n \"0.78837377\",\n \"0.78837377\",\n \"0.7865865\",\n \"0.78647953\",\n \"0.78617305\",\n \"0.7828202\",\n \"0.7802333\",\n \"0.77971953\",\n \"0.77971953\",\n \"0.77971953\",\n \"0.77971953\",\n \"0.77971953\",\n \"0.77971953\",\n \"0.7791782\",\n \"0.7786945\",\n \"0.7784728\",\n \"0.778366\",\n \"0.77768356\",\n \"0.77757293\",\n \"0.7772452\",\n \"0.77658075\",\n \"0.77658075\",\n \"0.77658075\",\n \"0.77658075\",\n \"0.7764756\",\n \"0.7750751\",\n \"0.77477163\",\n \"0.7730367\",\n \"0.7730367\",\n \"0.7722212\",\n \"0.77180296\",\n \"0.76961213\",\n \"0.7680976\",\n \"0.76797205\",\n \"0.76776814\",\n \"0.76760346\",\n \"0.76758707\",\n \"0.7674136\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24595,"cells":{"query":{"kind":"string","value":"Creates an address for a purchase."},"document":{"kind":"string","value":"def __init__(self, street=\"\", street2=\"\", city=\"\", state=\"\", zip_code=\"\"):\n self.street = street\n self.street2 = street2\n self.city = city\n self.state = state\n self.zip_code = zip_code"},"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 generateNewAddress(self, currency):\n pass","def create_address(self, address: str) -> Optional[Address]:\n raise NotImplemented","def test_create_shipping_address(self):\n self.cim.create_shipping_address(\n customer_profile_id=100,\n ship_phone=u'415-415-4154',\n ship_first_name=u'valentino'\n )","async def create_deposit_address(self, code: str, params={}):\n await self.load_markets()\n request = {\n 'op_renew': 1,\n }\n return await self.fetch_deposit_address(code, self.extend(request, params))","def createUserAddress(self,username):\n addr = self.api.getnewaddress()\n dct = {'USER_NAME':username, 'ADDRESS':addr}\n print dct\n address = self.getAdminAddress()\n txd = self.api.publishfrom(address, 'users_addresses',username,self.bin2hex(json.dumps(dct)))\n print txd\n return addr","def add_address(self, **kwargs):\n addressitem = AddressItem(**kwargs)\n self.addresses.append(addressitem)\n # TODO check uniqueness of email addresses","def test82_GenNewAddress(self):\n payload = {\n 'id': 0,\n 'params': {'amount': 100.0, 'qr_code': False, 'gen_new': False},\n 'jsonrpc': '2.0',\n 'method': 'create_order'\n }\n res = requests.post( url, data=json.dumps(payload), headers=headers).json()['result']\n self.assertEqual(res['receiving_address'], 'mjPS9N4T6cjcWLvdkv4jtCrzNA6C6qm8uv')\n self.assertEqual(res['amount'], '0.2860001')\n self.assertTrue(res['exact_amount'])\n order_id = res['order_id']\n payload = {\n 'id': 0, 'params': {'bindings':{'receiving_address': 'mjPS9N4T6cjcWLvdkv4jtCrzNA6C6qm8uv'}},\n 'jsonrpc': '2.0',\n 'method': 'get_address'\n }\n res = requests.post( url, data=json.dumps(payload), headers=headers).json()['result'][0]\n self.assertEqual(res['keypath'], '0/0/4')\n self.assertEqual(res['max_tx'], config.MAX_LEAF_TX)\n self.assertTrue(res['special_digits'] > 0)","def generate_deposit_address(self, asset: Asset,\n receive_window: Optional[int] = None):\n api_params = {\n 'asset': asset.value,\n 'timestamp': get_current_time_milliseconds()\n }\n\n if receive_window is not None:\n api_params['receiveWindow'] = receive_window\n\n return self.request.post(path='/deposit/address', json_data=api_params)","def create_or_update_address(address, customer):\n\tname = frappe.db.get_value('Address', { 'entity_id': address.get('entity_id') })\n\tif not name:\n\t\taddr = frappe.new_doc('Address')\n\t\taddr.address_title = \"{} {} {}\".format(\n\t\t\taddress.get(\"firstname\"),\n\t\t\taddress.get(\"lastname\"),\n\t\t\taddress.get(\"entity_id\")\n\t\t)\n\telse:\n\t\taddr = frappe.get_doc(\"Address\", name)\n\n\taddr.address_type = get_address_type(address).get('type')\n\taddr.entity_id = address.get('entity_id')\n\taddr.address_line1 = address.get('street')[0]\n\taddr.address_line2 = address.get('street')[1] if len(address.get('street')) > 1 else \"\"\n\taddr.city = address.get('city')\n\taddr.country = frappe.db.get_value('Country', { 'code': address.get('country_id') })\n\taddr.state = address.get('region')\n\taddr.pincode = address.get('postcode')\n\taddr.phone = address.get('telephone') or '00000'\n\taddr.fax = address.get('fax')\n\taddr.customer = customer\n\taddr.customer_name = address.get('firstname')+' '+address.get('lastname')\n\taddr.is_primary_address = get_address_type(address).get('is_primary_address')\n\taddr.is_shipping_address = get_address_type(address).get('is_shipping_address')\n\n\taddr.save(ignore_permissions=True)","def build_address(record):\n pass","def test81_GenNewAddress(self):\n payload = {\n 'id': 0,\n 'params': {'amount': 100.0, 'qr_code': False, 'gen_new': True, 'order_id': 'DUMMY_ORD_3'},\n 'jsonrpc': '2.0',\n 'method': 'create_order'\n }\n res = requests.post( url, data=json.dumps(payload), headers=headers).json()['result']\n self.assertEqual(res['amount'], '0.286')\n self.assertEqual(res['exact_amount'], False)\n self.assertEqual(res['receiving_address'], 'miXzTXvkEsfVmkwMjLCHfXAjboodrgQQ9Z')","def generate_deposit_address(self, currency):\n return self.__call__('balance', \"generatedepositaddress\", \n {\"currencyname\": currency})","def create_order(self, request):\n data = request.data\n address_id = request.query_params[\"address_id\"]\n # data._mutable = True\n data[\"user\"] = request.user.id\n data[\"address\"] = address_id\n serializer = OrderCreateSerializer(data=data)\n if serializer.is_valid():\n serializer.save()\n return Response({\"result\": serializer.data, \"message\": \"Done\", \"status\": True},\n status=status.HTTP_201_CREATED)\n return Response({\"result\": serializer.errors, \"message\": \"Done\", \"status\": False},\n status=status.HTTP_400_BAD_REQUEST)","def do_generate(self, args):\n if not len(args) == 0:\n self.wallet.generate_address(args)\n else:\n self.wallet.generate_address_randomKey()","def allocate_address(self, domain=None):\r\n params = {}\r\n\r\n if domain is not None:\r\n params['Domain'] = domain\r\n\r\n return self.get_object('AllocateAddress', params, Address, verb='POST')","def add_address(intent, session):\n slots = intent.get('slots')\n sess_data = session.setdefault('attributes', {})\n sess_data['add_address'] = True\n sess_data.setdefault('next_step', 'which')\n if sess_data['next_step'] == 'which':\n if slots['which_address'].get('value') in ORIGIN_NAMES:\n sess_data['which'] = 'origin'\n sess_data['next_step'] = 'num_and_name'\n return reply.build(\"Okay, storing your origin address. \"\n \"What's the street number and name?\",\n reprompt=\"What's the street number and name?\",\n persist=sess_data,\n is_end=False)\n elif slots['which_address'].get('value') in DEST_NAMES:\n sess_data['which'] = 'destination'\n sess_data['next_step'] = 'num_and_name'\n return reply.build(\"Okay, storing your destination address. \"\n \"What's the street number and name?\",\n reprompt=\"What's the street number and name?\",\n persist=sess_data,\n is_end=False)\n else:\n sess_data['next_step'] = 'which'\n return reply.build(\"Would you like to set the address here or at \"\n \"your destination?\",\n reprompt='You can say \"here\" or \"destination\".',\n persist=sess_data,\n is_end=False)\n elif sess_data['next_step'] == 'num_and_name':\n if slots['address_street'].get('value'):\n num = slots.get('address_number', {}).get('value', '')\n direction = slots.get('direction', {}).get('value', '')\n st = slots.get('address_street', {}).get('value', '')\n sess_data['spoken_address'] = (('%s %s %s' %\n (num, direction, st))\n .replace(' ', ' ')\n .strip())\n sess_data['next_step'] = 'zip'\n return reply.build(\"Got it. Now what's the zip code? \"\n \"You can tell me \"\n \"to skip it if you don't know.\",\n reprompt=\"What's the zip code?\",\n persist=sess_data,\n is_end=False)\n else:\n return reply.build(\"Please say a street number and street name.\",\n reprompt=\"What's the street number and name?\",\n persist=sess_data,\n is_end=False)\n elif sess_data['next_step'] == 'zip':\n if not slots['address_number'].get('value'):\n return reply.build(\"I need the zip code now.\",\n reprompt=\"What's the zip code?\",\n persist=sess_data,\n is_end=False)\n sess_data['next_step'] = 'check_address'\n sess_data['zip_code'] = slots['address_number']['value']\n return add_address(intent, session)\n elif sess_data['next_step'] == 'check_address':\n if sess_data['zip_code']:\n # Assume that network subscribers are always interested\n # in in-state addresses, but not necessarily in the city.\n addr = '%s, %s, %s' % (sess_data['spoken_address'],\n config.default_state,\n sess_data['zip_code'])\n else:\n # Without a zip code, assume the network's home city\n # to add necessary specificity.\n addr = '%s, %s, %s' % (sess_data['spoken_address'],\n config.default_city,\n config.default_state)\n lat, lon, full_address = geocoding.get_lat_lon(addr)\n if full_address.endswith(\", USA\"):\n # We don't need to keep the country name.\n full_address = full_address[:-5]\n\n if full_address.lower().startswith(\"%s, %s\" %\n (config.default_city.lower(),\n config.default_state.lower())):\n # If the geocoding fails to find a specific address,\n # it will return a generic city location.\n sess_data['next_step'] = 'num_and_name'\n return reply.build(\"I'm sorry, I heard the address \\\"%s\\\", \"\n \"but I can't figure out where that is. \"\n \"Try a different address, something I can \"\n \"look up on the map.\" % addr,\n reprompt=\"What's the street number and name?\",\n persist=sess_data,\n is_end=False)\n\n sess_data['latitude'], sess_data['longitude'] = lat, lon\n sess_data['full_address'] = full_address\n sess_data['next_step'] = 'store_address'\n return reply.build(\"Thanks! Do you want to set \"\n \"your %s address to %s?\" %\n (sess_data['which'],\n location.text_to_speech(full_address)),\n reprompt=\"Is that the correct address?\",\n persist=sess_data,\n is_end=False)\n elif sess_data['next_step'] == 'store_address':\n # The user should have said \"yes\" or \"no\" after\n # being asked if we should store the address.\n # Only get here if they didn't.\n full_address = sess_data['full_address']\n return reply.build(\"Sorry, I didn't understand that. \"\n \"Do you want to set \"\n \"your %s address to %s?\" %\n (sess_data['which'],\n location.text_to_speech(full_address)),\n reprompt=\"Is that the correct address?\",\n persist=sess_data,\n is_end=False)\n else:\n return reply.build(\"I'm sorry, I got confused. What do you mean?\",\n persist=sess_data,\n is_end=False)","def test_client_address_create(self):\n pass","def create_deposit_address(currency_code: str,\n exchange: str = CRYPTO_EXCHANGE,\n api_key: str = CRYPTO_API_KEY,\n api_secret: str = CRYPTO_API_SECRET,\n exchange_password: Any = CRYPTO_API_PASSWORD,\n exchange_uid: Any = CRYPTO_API_UID,\n test_mode: bool = False) -> Any:\n try:\n if test_mode == True:\n url = CRYPTO_URL_TEST\n else:\n url = CRYPTO_URL_LIVE\n payload = {'currency_code': currency_code}\n response = requests.post(\n '{}/create_deposit_address/{}'.format(url, exchange),\n headers=crypto_get_headers(api_key, api_secret, exchange_password,\n exchange_uid),\n json=payload)\n if response:\n return response.json()\n if response.status_code == 400:\n logger.error('Oops! An error Occurred ⚠️')\n raise BadRequest(response.text)\n if response.status_code == 401:\n logger.error('Oops! An error Occurred ⚠️')\n raise InvalidCredentials(response.text)\n except Exception as exception:\n logger.error('Oops! An error Occurred ⚠️')\n raise exception","def test_new_empty_shipping_address(self):\r\n self.original = self.env[\"res.partner\"].create({\r\n \"is_company\": False,\r\n \"type\": 'delivery',\r\n \"lastname\": \"\",\r\n \"firstname\": \"\"})","def create(cls, address, location='Default', dynamic=False):\n from smc.elements.helpers import location_helper\n location_ref = location_helper(location)\n address = [{'address': address,\n 'dynamic': dynamic,\n 'location_ref': location_ref}]\n return {'contact_addresses': address}","def test_address_other_parameters():\n address = lob.Address.create(name = 'Siddharth Saha', address_line1 = '104, Printing Boulevard',\n address_line2 = 'Sunset Town', email = 'sidchilling@gmail.com', \n address_city = 'Boston', address_state = 'MA', address_country = 'US',\n address_zip = '12345')\n print address.to_dict()","def test_address_other_parameters():\n address = lob.Address.create(name='Siddharth Saha', address_line1='104, Printing Boulevard',\n address_line2='Sunset Town', email='sidchilling@gmail.com',\n address_city='Boston', address_state='MA', address_country='US',\n address_zip='12345')\n print address.to_dict()","def toAddr(self, addressString: unicode) -> ghidra.program.model.address.Address:\n ...","def allocate_address():\n response = EC2.allocate_address(\n )\n return response","def test_create_new_address_with_permission(self):\n data = dict(\n address_line1='random address 2',\n postal_code='RAN DOM',\n city='random city',\n state_province=self.random_state_province.iso_code,\n country=self.random_country.iso_code,\n )\n\n self.client.force_authenticate(user=self.admin)\n\n response = self.client.post(\n reverse('location:addresses'),\n data,\n format='json',\n )\n\n data['address_line2'] = ''\n data['state_province'] = dict(\n name=self.random_state_province.name,\n iso_code=self.random_state_province.iso_code\n )\n data['country'] = dict(\n name=self.random_country.name,\n iso_code=self.random_country.iso_code\n )\n\n res = json.loads(response.content)\n del res['id']\n\n self.assertEqual(response.status_code, status.HTTP_201_CREATED)\n self.assertEqual(res, data)","def choose_new_address(self) -> \"CheckoutPage\":\n self.accordion = BillingDetailsUser(self.driver)\n self.accordion.btn_new_address.click()\n return self","def post(self, request, *args, **kwargs):\n request_data = request.data\n\n # create address serializers object\n serializer = self.serializer_class(data=request_data, context={'request': request})\n\n # check address serializers is valid\n if not serializer.is_valid():\n return APIResponse(serializer.errors, HTTP_400_BAD_REQUEST)\n\n validated_data = serializer.validated_data\n\n try:\n # verified address\n verifiedAddressRep = LobAddressVerification.verify_address(validated_data)\n except Exception as err:\n return APIResponse({\"message\": err.args[0]}, HTTP_400_BAD_REQUEST)\n\n print(\"======verifiedAddressRep=========\", verifiedAddressRep)\n # get last transaction save point id\n sid = transaction.savepoint()\n\n # try:\n # # save admin address\n # instance = serializer.create(validated_data)\n # except Exception as err:\n # logger.error(\"Unexpected error occurred : %s.\", err)\n # # roll back transaction if any exception occur while add new address\n # transaction.savepoint_rollback(sid)\n # return APIResponse({\"message\": err.args[0]}, HTTP_400_BAD_REQUEST)\n #\n # # convert model object into json\n # data = AddressViewSerializer(instance).data\n # data['message'] = ADD_ADDRESS\n\n return APIResponse(\"data\", HTTP_201_CREATED)","def get_or_create(self):\n if self.is_valid():\n address, created = Address.objects.get_or_create(\n street=self.cleaned_data['street'],\n city=self.cleaned_data['city'],\n state=self.cleaned_data['state'],\n country=self.cleaned_data['country'],\n postal_code=self.cleaned_data['postal_code'],\n )\n return address\n return None","def add_address(self, address_list=None):\n sql = u' INSERT INTO address_TBL ' \\\n u'(line_1, line_2, city, county, country, billing_address, main_address, client_company_ID) ' \\\n u'VALUES (%s, %s, %s, %s, %s, %s, %s, %s);'\n if address_list is None:\n address_list = self.data_set['address']\n\n c, conn = connection(self.schema)\n\n try:\n for address in address_list:\n if address['line_2'] is None:\n address['line_2'] = 'NULL'\n if address['billing'] is None:\n address['billing'] = 0\n if address['default'] is None:\n address['default'] = 0\n\n data = (address['line_1'],\n address['line_2'],\n address['city'],\n address['county'],\n address['country'],\n address['billing'],\n address['default'],\n self.id)\n\n c.execute(sql, data)\n finally:\n conn_close(c, conn)","def address(self, new_address):\n house_num, street_name, apt_num = new_address\n self._address.house_num = house_num\n self._address.street_name = street_name\n self._address.apt_num = apt_num","def do_charge_purchase_create(cs, args):\n purchase = cs.charge_purchases.create(args.purchase_name)\n utils.print_dict(purchase._info)","def add_new_address(self, address: dict) -> None:\n self.new_address_button.click()\n\n self.address_form.select_location(address['address'])\n self.address_form.label_input.fill(address['name'])\n\n self.address_form.save_button.click()","def as_address(self, base_clazz):\n address = base_clazz()\n address.name = self.name\n address.line1 = self.line1\n address.line2 = self.line2\n address.city = self.city\n address.region = self.region\n address.country = self.country\n address.post_code = self.post_code\n address.phone = self.phone\n return address","def create_shop(shop_id, name, lat, lng, address_num=None, address_street=None, zipcode=None):\n\n shop = Shop(shop_id=shop_id, name=name, address_num=address_num, \n address_street=address_street, zipcode=zipcode, lat=lat, lng=lng)\n db.session.add(shop)\n db.session.commit()\n return shop","def generate_address(self, private_key):\n words, seed = CryptoUtils.create_mnemonic_key(private_key)\n private_key_to_hex = CryptoUtils.generate_private_key(seed)\n public_key = CryptoUtils.generate_public_key(private_key_to_hex)\n public_key_compressed = CryptoUtils.compress_public_key(public_key)\n address = CryptoUtils.generate_address(public_key)\n self.addresses[address] = {\n 'owner_key': private_key,\n 'private_key': private_key_to_hex,\n 'mnemonic_words': words,\n 'public_key': public_key,\n 'public_key_compressed': public_key_compressed,\n 'balance': 0\n }","def test_new_empty_invoice_address(self):\r\n self.original = self.env[\"res.partner\"].create({\r\n \"is_company\": False,\r\n \"type\": 'invoice',\r\n \"lastname\": \"\",\r\n \"firstname\": \"\"})","def save_object(self, data):\n return Address(**data)","def createAddressSet(self) -> ghidra.program.model.address.AddressSet:\n ...","def get_address(self, list_item):\n Address = namedtuple('Address', ['addr', 'city', 'state', 'zip'])\n extract = [text for text in list_item.find('address').stripped_strings]\n\n # Sometimes a street address is not given\n if len(extract) == 1:\n addr, rest = None, extract[0]\n else:\n addr, rest = extract\n\n city, rest = rest.split(',')\n state, zip = rest.strip().split(' ')\n return Address(addr, city, state, zip)","def make_address_from_passphrase(passphrase, compressed=True, as_str=True):\n if not isinstance(passphrase, bytes):\n passphrase = bytes(passphrase, \"utf-8\")\n passphrasehash = hashlib.sha256(passphrase).digest()\n private_key = CBitcoinSecret.from_secret_bytes(passphrasehash, compressed=compressed)\n address = P2PKHBitcoinAddress.from_pubkey(private_key.pub)\n if as_str:\n return str(address)\n else:\n return address","def set_address(self, address):\n if address == \"\":\n self.address = Address(\"\", \"\", \"\")\n else:\n self.address = address","def _generate_new_address(self) -> str:\n while True:\n address = \"0x\" + \"\".join([str(hex(randint(0, 16)))[-1] for _ in range(20)])\n if address not in self.accounts.keys():\n return address","def add_addressitem(self, addressitem):\n self.addresses.append(addressitem)","def _addressitem_from_line(line):\n sline = line.split(\"\\t\")\n if len(sline) < 2:\n raise IOError(\"Error parsing address from line. Malformed data.\")\n address = sline[0]\n name = sline[1]\n\n if len(sline) > 2:\n otherinfo = sline[2]\n else:\n otherinfo = \"\"\n if len(sline) > 3:\n extrainfo = sline[3]\n else:\n extrainfo = \"\"\n if len(sline) > 4:\n raw_misc = sline[4:]\n misc = _raw_misc_to_dict(raw_misc)\n else:\n misc = {}\n\n return AddressItem(\n _email_address=address,\n _name=name,\n _otherinfo=otherinfo,\n _extrainfo=extrainfo,\n **misc\n )","def test_get_order_address(self):\n pass","def deposit_address(self):\n response = self.query('deposit_address')\n return response","def add_address(self, address_item):\r\n self.addresses_to_validate.append(address_item)","def do_addresses(self, args):\n pprint(self.wallet.addresses)","def on_GenerateRandomAccountAddress_clicked(self):\n # TODO: not implemented yet\n raise NotImplementedError","def create_supplier(name: str, short_name: str, address: str) -> Supplier:\n return Supplier(name, short_name, address)","def generate_address(rpc_user, rpc_pwd, observer):\n data = ('{\"jsonrpc\":\"2.0\",\"id\":\"1\",\"method\":\"getnewaddress\",' +\n '\"params\":[\"Observer\"]}'.replace('Observer', observer))\n return call_rpc(rpc_user, rpc_pwd, data)","def get_address(self):\n\n return \"{}\\n{}\\n{},\\n{},\\n{}\".format(\n self.address_line_1, self.city, self.state, self.postal_code, self.country\n )","def purchase_ip(self, debug=False):\n json_scheme = self.gen_def_json_scheme('SetPurchaseIpAddress')\n json_obj = self.call_method_post(method='SetPurchaseIpAddress', json_scheme=json_scheme, debug=debug)\n try:\n ip = Ip()\n ip.ip_addr = json_obj['Value']['Value']\n ip.resid = json_obj['Value']['ResourceId']\n return ip\n except:\n raise Exception('Unknown error retrieving IP.')","def test_create_address(self): \n url = reverse('v1:addresses-list', args=[1])\n profile = ProfileFactory.create()\n \n address_data = {'profile' : str(profile.id),\n 'street_address' : 'test street',\n 'city' : 'test city',\n 'state' : 'test state', \n 'zip_code' : 'test zip',\n 'country' : 'test country',\n }\n\n # Check Anonymous User should return 403\n response = self.client.post(url, address_data, format='json')\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)\n\n # Profile Owner User\n self.client.credentials(Authorization='Bearer ' + 'regularusertoken')\n response = self.client.post(url, address_data, format='json')\n response_data = response.json()\n self.assertEqual(response.status_code, status.HTTP_201_CREATED)\n \n self.assertIsNotNone(response_data[\"profile\"])\n self.assertEqual(ProfileAddress.objects.get(profile=response_data['profile']).street_address, 'test street')\n self.assertEqual(ProfileAddress.objects.get(profile=response_data['profile']).city, address_data['city'])\n self.assertEqual(len(ProfileAddress.objects.all()), 1)\n self.assertEqual(Profile.objects.get(pk=profile.id).id, uuid.UUID(response_data['profile']))","def address(self):\n return str(self.street) + str(self.city) + str(self.state) + str(self.zipcode)","def test_to_address(mocker):\n transaction = Transaction(\n chain=1,\n nonce=10,\n fee=50,\n value=5_000_000,\n to_address=\"1H7NtUENrEbwSVm52fHePzBnu4W3bCqimP\",\n unlock_sig=Config.COINBASE_UNLOCK_SIGNATURE,\n )\n\n assert transaction.validate() == True\n assert transaction.validate(raise_exception=True) == True\n\n transaction.to_address = \"1H7NtUENrEbwSVm52fHePzBnu4W3bCqimPX\"\n assert transaction.validate() == False\n with pytest.raises(\n TransactionNotValid, match=errors.TRANSACTION_FIELD_TO_ADDRESS\n ):\n transaction.validate(raise_exception=True)","def getNewAddress(self):\n a = self.selectedAccount.getNextPaymentAddress()\n if self.blockchain:\n self.blockchain.subscribeAddresses(a)\n self.save()\n return a","def choose_new_address_delivery(self) -> \"CheckoutPage\":\n self.accordion = DeliveryDetailsUser(self.driver)\n self.accordion.btn_new_address_delivery.click()\n return self","def ship_to_pickup_address(self, address):\n self._set('shipping', 'pickup_address_id', address.id)","def generate_address(self, meta, network: int) -> Address:\n raise NotImplemented","def set_address(self, new_address, ):\n self.address.append(new_address)\n self.save()","def make_address(pubkeys, n):\n return (str(len(pubkeys)) + str(n) +\n base58_encode(det_hash({str(n): pubkeys}))[0:29])","def post(self):\n return self.get_request_handler(request.headers).create_new_address(request)","def store_address(intent, session):\n sess_data = session.setdefault('attributes', {})\n if not sess_data.get('add_address') and \\\n not sess_data['next_step'] == 'store_address':\n raise RuntimeError('Something went wrong.')\n\n data = {sess_data['which']: dict(latitude=str(sess_data['latitude']),\n longitude=str(sess_data['longitude']),\n address=str(sess_data['full_address']))}\n success = database.update_user_data(session['user']['userId'], **data)\n if not success:\n return reply.build(\"I'm sorry, something went wrong and I could't \"\n \"store the address.\", is_end=True)\n else:\n return reply.build(\"Okay, I've saved your %s \"\n \"address.\" % sess_data['which'],\n is_end=True)","def do_getaddress(self,args):\n ppdict(bitstamp.get_depositaddress())","def create_addressbook(parent, name, title=None):\n ab = icemac.addressbook.utils.create_obj(\n icemac.addressbook.addressbook.AddressBook)\n if title is not None:\n ab.title = title\n parent[name] = ab\n return ab","def generate_address_randomKey(self):\n private_key = CryptoUtils.generate_random_private_key()\n self.generate_address(private_key)","def createBilling(self, loginName, password, data):\n return self.talk('purchase',\n data=self.__makeLoginDict(loginName, password, data))","def address(self, address: object):\n\n self._address = address","def createSymbol(self, address: ghidra.program.model.address.Address, name: unicode, makePrimary: bool) -> ghidra.program.model.symbol.Symbol:\n ...","def record_purchase(params, order):\r\n ccnum_str = params.get('card_accountNumber', '')\r\n m = re.search(\"\\d\", ccnum_str)\r\n if m:\r\n ccnum = ccnum_str[m.start():]\r\n else:\r\n ccnum = \"####\"\r\n\r\n order.purchase(\r\n first=params.get('billTo_firstName', ''),\r\n last=params.get('billTo_lastName', ''),\r\n street1=params.get('billTo_street1', ''),\r\n street2=params.get('billTo_street2', ''),\r\n city=params.get('billTo_city', ''),\r\n state=params.get('billTo_state', ''),\r\n country=params.get('billTo_country', ''),\r\n postalcode=params.get('billTo_postalCode', ''),\r\n ccnum=ccnum,\r\n cardtype=CARDTYPE_MAP[params.get('card_cardType', 'UNKNOWN')],\r\n processor_reply_dump=json.dumps(params)\r\n )","def test_create_email_address(self):\n email_addr = 'testcreate@' + self.email_dom\n org = 'o=%s' % (self.org_name)\n people = '%s=%s' % (self.container_attr, self.user_container)\n uid = '%s=%s' % (self.user_key, self.user_id)\n dn = '%s,%s,%s,%s' % (uid, people, org, self.base_dn)\n dn_info = {self.smtp_address: [email_addr]}\n expected_result = [(dn, dn_info)] \n addr = SpokeEmailAddress(self.org_name, self.user_id)\n result = addr.create(email_addr)['data']\n self.assertEqual(result, expected_result)","def type_address(self, address):\n\n\t\twith allure.step(\"Type payee address\"):\n\t\t\telement = Element(driver=self.driver,\n\t\t\t explicit_wait_time=self.explicit_wait_time,\n\t\t\t locator=BillPayPageLocator.ADDRESS_INPUT)\n\t\t\telement.write(address)\n\t\t\treturn None","def toAddr(self, offset: int) -> ghidra.program.model.address.Address:\n ...","def address():\n # We start with generating the street name. For this we choose\n # between the most common prefixes and our own prefixes\n prefix = dice.randint(1, 100)\n if prefix <= 10: # 10%\n prefix = \"Haupt\"\n elif prefix <= 18: # 8%\n prefix = \"Schul\"\n elif prefix <= 25: # 7%\n prefix = \"Garten\"\n elif prefix <= 32: # 7%\n prefix = \"Dorf\"\n elif prefix <= 39: # 7%\n prefix = \"Bahnhof\"\n elif prefix <= 46: # 7%\n prefix = \"Wiesen\"\n elif prefix <= 52: # 6%\n prefix = \"Berg\"\n elif prefix <= 56: # 4%\n prefix = \"Kirch\"\n elif prefix <= 60: # 4%\n prefix = \"Wald\"\n elif prefix <= 64: # 4%\n prefix = \"Ring\"\n else:\n prefix = dice.choice(names.prefix)\n\n # Now we can add the suffix\n suffix = dice.randint(1, 100)\n if suffix <= 78:\n suffix = \"straße\"\n elif suffix <= 96:\n suffix = \"weg\"\n elif suffix <= 98:\n suffix = \"allee\"\n elif suffix == 99:\n suffix = \"ring\"\n elif suffix == 100:\n suffix = \"platz\"\n\n # When we have a city name as prefix, we need to capitalize the\n # suffix since it will be two words\n if prefix[-1] == \" \":\n suffix = suffix.capitalize()\n\n # Now we can add them together\n street = prefix + suffix\n\n # We need a house number as well. In Germany most numbers have\n # between one and four digits, so we will use this as base. Lower\n # numbers are more common, so we'll give it a 10% probability of\n # using 3 digits and 1% of using 4 digits\n digits = dice.randint(1, 100)\n if digits == 100:\n house_number = str(dice.randint(1000, 9999))\n elif digits >= 90:\n house_number = str(dice.randint(100, 999))\n else:\n house_number = str(dice.randint(1, 99))\n address_full = street + \" \" + house_number\n return address_full","def on_GenerateRandomAccountAddress_2_clicked(self):\n # TODO: not implemented yet\n raise NotImplementedError","def create_and_verify(cls, api_key: Optional[str] = None, **params) -> \"Address\":\n requestor = Requestor(local_api_key=api_key)\n url = \"%s/%s\" % (cls.class_url(), \"create_and_verify\")\n\n wrapped_params = {cls.snakecase_name(): params}\n response, api_key = requestor.request(method=RequestMethod.POST, url=url, params=wrapped_params)\n\n return convert_to_easypost_object(response=response[\"address\"], api_key=api_key)","def get_new_address(self):\n key = generate_key(generate_random())\n address = pubtoaddr(key[\"public\"])\n self.keyring.append(key)\n write_keys(self.path, self.keyring)\n return address","def create_order(self, openid, **kwargs):\n data = kwargs\n data['openid'] = openid\n\n self._check_create_order(**data)\n\n order_data = {\n 'appid': self.appid,\n 'mch_id': self.mch_id,\n 'nonce_str': uuid.uuid4().hex,\n 'body': kwargs.get('title'),\n 'out_trade_no': kwargs.get('order_uid'),\n 'total_fee': int(kwargs.get('total') * 100),\n 'notify_url': kwargs.get('notify_url'),\n 'spbill_create_ip': kwargs.get('ip'),\n 'trade_type': kwargs.get('trade_type')\n }\n fields = ('detail', 'time_expire', 'time_start', 'openid',\n 'product_id')\n for field in fields:\n if field in kwargs:\n order_data[field] = kwargs[field]\n\n return self.send_data(self.UNIFIED_ORDER_URL, **order_data)","def getnewaddress(self):\n passphrase = self._getnewaddress_passphrase_template.format(self._getnewaddress_offset)\n address = make_address_from_passphrase(bytes(passphrase, \"utf-8\"))\n self._getnewaddress_offset += 1\n return CBitcoinAddress(address)","def getnewaddress(self, account=None):\n if account is None:\n return self.proxy.getnewaddress()\n else:\n return self.proxy.getnewaddress(account)","def save(self, *args, **kwargs):\n # Save a hash of the address fields so we can check whether two\n # addresses are the same to avoid saving duplicates\n # self.hash = self.generate_hash()\n\n # Ensure that each user only has one default shipping address\n # and billing address\n self._ensure_defaults_integrity()\n super(UserAddress, self).save(*args, **kwargs)","def test_get_shipping_address(self):\n self.cim.get_shipping_address(\n customer_profile_id=u\"900\",\n customer_address_id=u\"344\"\n )","def main(options):\n home = Address(options.name,\n options.address,\n options.city,\n options.state,\n options.zip_code)","def create_order(self, serializer):\n data = serializer.validated_data\n service: Service = data['service']\n customer: Customer = Customer.objects.get_or_create(\n email=data['email'])[0]\n invoice: Invoice = Invoice(\n charged_amount=service.price.amount,\n currency=service.price.currency,\n timestamp=now(),\n customer=customer,\n service=service\n )\n invoice.save()\n serializer.validated_data['invoice_id'] = invoice.id\n serializer.save()\n\n self.send_order_email(invoice, serializer.instance)","def address(self, address: str):\n\n self._address = address","def GenerateAddressBook(self, node):\n if not self.addressbook:\n return\n addrs = Tree('addresses')\n addrs.AddParent(node)\n index=0\n for zone in self.addressbook:\n # building individual addresses\n groups = sorted(self.addressbook[zone])\n for group in groups:\n ips = nacaddr.SortAddrList(self.addressbook[zone][group])\n ips = nacaddr.CollapseAddrList(ips)\n self.addressbook[zone][group] = ips\n count = index + 0\n for address in self.addressbook[zone][group]:\n prefix_type = 'ipv4-prefix '\n if isinstance( address, nacaddr.IPv6):\n prefix_type = 'ipv6-prefix '\n addr_list = Tree('address'+' _' + group, prefix_type +\n ' ' + str(address) + ';')\n addr_list.AddParent(addrs)\n count += 1\n index += count\n\n addr_groups=Tree('address-groups')\n addr_groups.AddParent(node)\n for zone in self.addressbook:\n # building address-sets\n addrlist = ''\n for group in self.addressbook[zone]:\n addrlist = addrlist + '_' + group + ' '\n group_t=Tree('group ' + zone, 'address-list [ ' + addrlist + '];')\n group_t.AddParent(addr_groups)","def _unique_address(self, **kwargs):\n pass","def toAddr(self, offset: long) -> ghidra.program.model.address.Address:\n ...","def CreateCustomer(Person):\n\t\t\tif Person.AddrCitytownNrID:\n\t\t\t\tcitytown = model.AddressCityTown.get(Person.AddrCitytownNrID)\n\t\t\t\tAddressLabel = '%s\\n%s\\n%s, %s\\n%s\\n%s' % (Person.AddrStr, citytown.Name, citytown.Block, citytown.District, citytown.State, citytown.ZipCode) \n\t\t\telse:\n\t\t\t\tAddressLabel = Person.AddrStr\n\t\t\tPersonName = ('%s %s,%s,%s' % (Person.Title, Person.NameFirst, Person.NameMiddle, Person.NameLast)).replace(',,',',').replace(',', ' ').strip()\n\t\t\tcustomer = model.InvCustomer(Name=PersonName ,CityID=Person.AddrCitytownNrID , AddressLabel=AddressLabel, CreditAmount=0.0, \\\n\t\t\t\tInventoryLocation=self.GetDefaultCustomerLocationID(), ExternalID=Person.id)\n\t\t\treturn customer","def get_apartment_address(self, soup, apartment_dict):\n\n info_class = soup.find_all('div', {'class': 'info'})\n if info_class and len(info_class) > 0:\n info_class = info_class[0]\n address = info_class.find('h2').text.strip()\n\n from parse import parse\n address = parse(\"Location: {}\", address)[0]\n apartment_dict['address'] = address\n else:\n logging.warning(\"Failed to parse apartment address\")\n return","def _set_address(self, v, load=False):\n try:\n t = YANGDynClass(v,base=[unicode,unicode,unicode,unicode,unicode,], is_leaf=True, yang_name=\"address\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True)\n except (TypeError, ValueError):\n raise ValueError(\"\"\"address must be of a type compatible with base=[unicode,unicode,unicode,unicode,unicode,], is_leaf=True, yang_name=\"address\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True\"\"\")\n self.__address = t\n if hasattr(self, '_set'):\n self._set()","def getAddressAtIndex(self, index: int) -> ghidra.program.model.address.Address:\n ...","def street_address():\r\n\r\n return _random.choice(\r\n [\r\n '%d-%d %s' % (\r\n _random.randrange(999),\r\n _random.randrange(999),\r\n street_name()\r\n ),\r\n '%d %s' % (\r\n _random.randrange(999),\r\n street_name()\r\n ),\r\n '%s %d, %s' % (\r\n 'P.O. Box',\r\n _random.randrange(999),\r\n street_name()\r\n )\r\n ]\r\n )","def createSymbol(self, address: ghidra.program.model.address.Address, name: unicode, makePrimary: bool, makeUnique: bool, sourceType: ghidra.program.model.symbol.SourceType) -> ghidra.program.model.symbol.Symbol:\n ...","def set_address(self, address):\n pass","def nameToAddress(self, name):\n pass","def create(self, values):\n if values.get('name', _('New')) == _('New'):\n values['name'] = self.env['ir.sequence'].next_by_code('order.reference',\n None) or _('New')\n values['marks'] = values['name']\n customer_code = ''\n if values.get('customer_id'):\n customer = self.env['res.partner'].browse(values.get('customer_id'))\n customer_code = customer.customer_code\n if values.get('marks'):\n marks_field = values.get('marks')\n else:\n marks_field = ' '\n\n values['marks'] = '%s %s %s' % (customer_code, values['name'], marks_field)\n return super(PurchaseOrder, self).create(values)","def add_merchant(street, merchant):\r\n street.append(merchant)","def get_postal_address(self):\n # print \"getting postal address\"\n address = []\n if self.name:\n address.append(self.name)\n if self.number:\n address.append(self.number + \" \" + self.street) # because building numbers and street names go on the same line\n elif self.street:\n address.append(self.street)\n if self.additional_street_address:\n address.append(self.additional_street_address)\n if self.site.post_town:\n address.append(self.site.post_town + \" \" + self.postcode)\n elif self.postcode:\n address.append(self.postcode)\n return address","def test_update_shipping_address(self):\n self.cim.update_shipping_address(\n customer_profile_id=u\"222\",\n customer_address_id=u\"444\",\n first_name=u\"pippo\",\n phone=u\"415-415-4154\"\n )"],"string":"[\n \"def generateNewAddress(self, currency):\\n pass\",\n \"def create_address(self, address: str) -> Optional[Address]:\\n raise NotImplemented\",\n \"def test_create_shipping_address(self):\\n self.cim.create_shipping_address(\\n customer_profile_id=100,\\n ship_phone=u'415-415-4154',\\n ship_first_name=u'valentino'\\n )\",\n \"async def create_deposit_address(self, code: str, params={}):\\n await self.load_markets()\\n request = {\\n 'op_renew': 1,\\n }\\n return await self.fetch_deposit_address(code, self.extend(request, params))\",\n \"def createUserAddress(self,username):\\n addr = self.api.getnewaddress()\\n dct = {'USER_NAME':username, 'ADDRESS':addr}\\n print dct\\n address = self.getAdminAddress()\\n txd = self.api.publishfrom(address, 'users_addresses',username,self.bin2hex(json.dumps(dct)))\\n print txd\\n return addr\",\n \"def add_address(self, **kwargs):\\n addressitem = AddressItem(**kwargs)\\n self.addresses.append(addressitem)\\n # TODO check uniqueness of email addresses\",\n \"def test82_GenNewAddress(self):\\n payload = {\\n 'id': 0,\\n 'params': {'amount': 100.0, 'qr_code': False, 'gen_new': False},\\n 'jsonrpc': '2.0',\\n 'method': 'create_order'\\n }\\n res = requests.post( url, data=json.dumps(payload), headers=headers).json()['result']\\n self.assertEqual(res['receiving_address'], 'mjPS9N4T6cjcWLvdkv4jtCrzNA6C6qm8uv')\\n self.assertEqual(res['amount'], '0.2860001')\\n self.assertTrue(res['exact_amount'])\\n order_id = res['order_id']\\n payload = {\\n 'id': 0, 'params': {'bindings':{'receiving_address': 'mjPS9N4T6cjcWLvdkv4jtCrzNA6C6qm8uv'}},\\n 'jsonrpc': '2.0',\\n 'method': 'get_address'\\n }\\n res = requests.post( url, data=json.dumps(payload), headers=headers).json()['result'][0]\\n self.assertEqual(res['keypath'], '0/0/4')\\n self.assertEqual(res['max_tx'], config.MAX_LEAF_TX)\\n self.assertTrue(res['special_digits'] > 0)\",\n \"def generate_deposit_address(self, asset: Asset,\\n receive_window: Optional[int] = None):\\n api_params = {\\n 'asset': asset.value,\\n 'timestamp': get_current_time_milliseconds()\\n }\\n\\n if receive_window is not None:\\n api_params['receiveWindow'] = receive_window\\n\\n return self.request.post(path='/deposit/address', json_data=api_params)\",\n \"def create_or_update_address(address, customer):\\n\\tname = frappe.db.get_value('Address', { 'entity_id': address.get('entity_id') })\\n\\tif not name:\\n\\t\\taddr = frappe.new_doc('Address')\\n\\t\\taddr.address_title = \\\"{} {} {}\\\".format(\\n\\t\\t\\taddress.get(\\\"firstname\\\"),\\n\\t\\t\\taddress.get(\\\"lastname\\\"),\\n\\t\\t\\taddress.get(\\\"entity_id\\\")\\n\\t\\t)\\n\\telse:\\n\\t\\taddr = frappe.get_doc(\\\"Address\\\", name)\\n\\n\\taddr.address_type = get_address_type(address).get('type')\\n\\taddr.entity_id = address.get('entity_id')\\n\\taddr.address_line1 = address.get('street')[0]\\n\\taddr.address_line2 = address.get('street')[1] if len(address.get('street')) > 1 else \\\"\\\"\\n\\taddr.city = address.get('city')\\n\\taddr.country = frappe.db.get_value('Country', { 'code': address.get('country_id') })\\n\\taddr.state = address.get('region')\\n\\taddr.pincode = address.get('postcode')\\n\\taddr.phone = address.get('telephone') or '00000'\\n\\taddr.fax = address.get('fax')\\n\\taddr.customer = customer\\n\\taddr.customer_name = address.get('firstname')+' '+address.get('lastname')\\n\\taddr.is_primary_address = get_address_type(address).get('is_primary_address')\\n\\taddr.is_shipping_address = get_address_type(address).get('is_shipping_address')\\n\\n\\taddr.save(ignore_permissions=True)\",\n \"def build_address(record):\\n pass\",\n \"def test81_GenNewAddress(self):\\n payload = {\\n 'id': 0,\\n 'params': {'amount': 100.0, 'qr_code': False, 'gen_new': True, 'order_id': 'DUMMY_ORD_3'},\\n 'jsonrpc': '2.0',\\n 'method': 'create_order'\\n }\\n res = requests.post( url, data=json.dumps(payload), headers=headers).json()['result']\\n self.assertEqual(res['amount'], '0.286')\\n self.assertEqual(res['exact_amount'], False)\\n self.assertEqual(res['receiving_address'], 'miXzTXvkEsfVmkwMjLCHfXAjboodrgQQ9Z')\",\n \"def generate_deposit_address(self, currency):\\n return self.__call__('balance', \\\"generatedepositaddress\\\", \\n {\\\"currencyname\\\": currency})\",\n \"def create_order(self, request):\\n data = request.data\\n address_id = request.query_params[\\\"address_id\\\"]\\n # data._mutable = True\\n data[\\\"user\\\"] = request.user.id\\n data[\\\"address\\\"] = address_id\\n serializer = OrderCreateSerializer(data=data)\\n if serializer.is_valid():\\n serializer.save()\\n return Response({\\\"result\\\": serializer.data, \\\"message\\\": \\\"Done\\\", \\\"status\\\": True},\\n status=status.HTTP_201_CREATED)\\n return Response({\\\"result\\\": serializer.errors, \\\"message\\\": \\\"Done\\\", \\\"status\\\": False},\\n status=status.HTTP_400_BAD_REQUEST)\",\n \"def do_generate(self, args):\\n if not len(args) == 0:\\n self.wallet.generate_address(args)\\n else:\\n self.wallet.generate_address_randomKey()\",\n \"def allocate_address(self, domain=None):\\r\\n params = {}\\r\\n\\r\\n if domain is not None:\\r\\n params['Domain'] = domain\\r\\n\\r\\n return self.get_object('AllocateAddress', params, Address, verb='POST')\",\n \"def add_address(intent, session):\\n slots = intent.get('slots')\\n sess_data = session.setdefault('attributes', {})\\n sess_data['add_address'] = True\\n sess_data.setdefault('next_step', 'which')\\n if sess_data['next_step'] == 'which':\\n if slots['which_address'].get('value') in ORIGIN_NAMES:\\n sess_data['which'] = 'origin'\\n sess_data['next_step'] = 'num_and_name'\\n return reply.build(\\\"Okay, storing your origin address. \\\"\\n \\\"What's the street number and name?\\\",\\n reprompt=\\\"What's the street number and name?\\\",\\n persist=sess_data,\\n is_end=False)\\n elif slots['which_address'].get('value') in DEST_NAMES:\\n sess_data['which'] = 'destination'\\n sess_data['next_step'] = 'num_and_name'\\n return reply.build(\\\"Okay, storing your destination address. \\\"\\n \\\"What's the street number and name?\\\",\\n reprompt=\\\"What's the street number and name?\\\",\\n persist=sess_data,\\n is_end=False)\\n else:\\n sess_data['next_step'] = 'which'\\n return reply.build(\\\"Would you like to set the address here or at \\\"\\n \\\"your destination?\\\",\\n reprompt='You can say \\\"here\\\" or \\\"destination\\\".',\\n persist=sess_data,\\n is_end=False)\\n elif sess_data['next_step'] == 'num_and_name':\\n if slots['address_street'].get('value'):\\n num = slots.get('address_number', {}).get('value', '')\\n direction = slots.get('direction', {}).get('value', '')\\n st = slots.get('address_street', {}).get('value', '')\\n sess_data['spoken_address'] = (('%s %s %s' %\\n (num, direction, st))\\n .replace(' ', ' ')\\n .strip())\\n sess_data['next_step'] = 'zip'\\n return reply.build(\\\"Got it. Now what's the zip code? \\\"\\n \\\"You can tell me \\\"\\n \\\"to skip it if you don't know.\\\",\\n reprompt=\\\"What's the zip code?\\\",\\n persist=sess_data,\\n is_end=False)\\n else:\\n return reply.build(\\\"Please say a street number and street name.\\\",\\n reprompt=\\\"What's the street number and name?\\\",\\n persist=sess_data,\\n is_end=False)\\n elif sess_data['next_step'] == 'zip':\\n if not slots['address_number'].get('value'):\\n return reply.build(\\\"I need the zip code now.\\\",\\n reprompt=\\\"What's the zip code?\\\",\\n persist=sess_data,\\n is_end=False)\\n sess_data['next_step'] = 'check_address'\\n sess_data['zip_code'] = slots['address_number']['value']\\n return add_address(intent, session)\\n elif sess_data['next_step'] == 'check_address':\\n if sess_data['zip_code']:\\n # Assume that network subscribers are always interested\\n # in in-state addresses, but not necessarily in the city.\\n addr = '%s, %s, %s' % (sess_data['spoken_address'],\\n config.default_state,\\n sess_data['zip_code'])\\n else:\\n # Without a zip code, assume the network's home city\\n # to add necessary specificity.\\n addr = '%s, %s, %s' % (sess_data['spoken_address'],\\n config.default_city,\\n config.default_state)\\n lat, lon, full_address = geocoding.get_lat_lon(addr)\\n if full_address.endswith(\\\", USA\\\"):\\n # We don't need to keep the country name.\\n full_address = full_address[:-5]\\n\\n if full_address.lower().startswith(\\\"%s, %s\\\" %\\n (config.default_city.lower(),\\n config.default_state.lower())):\\n # If the geocoding fails to find a specific address,\\n # it will return a generic city location.\\n sess_data['next_step'] = 'num_and_name'\\n return reply.build(\\\"I'm sorry, I heard the address \\\\\\\"%s\\\\\\\", \\\"\\n \\\"but I can't figure out where that is. \\\"\\n \\\"Try a different address, something I can \\\"\\n \\\"look up on the map.\\\" % addr,\\n reprompt=\\\"What's the street number and name?\\\",\\n persist=sess_data,\\n is_end=False)\\n\\n sess_data['latitude'], sess_data['longitude'] = lat, lon\\n sess_data['full_address'] = full_address\\n sess_data['next_step'] = 'store_address'\\n return reply.build(\\\"Thanks! Do you want to set \\\"\\n \\\"your %s address to %s?\\\" %\\n (sess_data['which'],\\n location.text_to_speech(full_address)),\\n reprompt=\\\"Is that the correct address?\\\",\\n persist=sess_data,\\n is_end=False)\\n elif sess_data['next_step'] == 'store_address':\\n # The user should have said \\\"yes\\\" or \\\"no\\\" after\\n # being asked if we should store the address.\\n # Only get here if they didn't.\\n full_address = sess_data['full_address']\\n return reply.build(\\\"Sorry, I didn't understand that. \\\"\\n \\\"Do you want to set \\\"\\n \\\"your %s address to %s?\\\" %\\n (sess_data['which'],\\n location.text_to_speech(full_address)),\\n reprompt=\\\"Is that the correct address?\\\",\\n persist=sess_data,\\n is_end=False)\\n else:\\n return reply.build(\\\"I'm sorry, I got confused. What do you mean?\\\",\\n persist=sess_data,\\n is_end=False)\",\n \"def test_client_address_create(self):\\n pass\",\n \"def create_deposit_address(currency_code: str,\\n exchange: str = CRYPTO_EXCHANGE,\\n api_key: str = CRYPTO_API_KEY,\\n api_secret: str = CRYPTO_API_SECRET,\\n exchange_password: Any = CRYPTO_API_PASSWORD,\\n exchange_uid: Any = CRYPTO_API_UID,\\n test_mode: bool = False) -> Any:\\n try:\\n if test_mode == True:\\n url = CRYPTO_URL_TEST\\n else:\\n url = CRYPTO_URL_LIVE\\n payload = {'currency_code': currency_code}\\n response = requests.post(\\n '{}/create_deposit_address/{}'.format(url, exchange),\\n headers=crypto_get_headers(api_key, api_secret, exchange_password,\\n exchange_uid),\\n json=payload)\\n if response:\\n return response.json()\\n if response.status_code == 400:\\n logger.error('Oops! An error Occurred ⚠️')\\n raise BadRequest(response.text)\\n if response.status_code == 401:\\n logger.error('Oops! An error Occurred ⚠️')\\n raise InvalidCredentials(response.text)\\n except Exception as exception:\\n logger.error('Oops! An error Occurred ⚠️')\\n raise exception\",\n \"def test_new_empty_shipping_address(self):\\r\\n self.original = self.env[\\\"res.partner\\\"].create({\\r\\n \\\"is_company\\\": False,\\r\\n \\\"type\\\": 'delivery',\\r\\n \\\"lastname\\\": \\\"\\\",\\r\\n \\\"firstname\\\": \\\"\\\"})\",\n \"def create(cls, address, location='Default', dynamic=False):\\n from smc.elements.helpers import location_helper\\n location_ref = location_helper(location)\\n address = [{'address': address,\\n 'dynamic': dynamic,\\n 'location_ref': location_ref}]\\n return {'contact_addresses': address}\",\n \"def test_address_other_parameters():\\n address = lob.Address.create(name = 'Siddharth Saha', address_line1 = '104, Printing Boulevard',\\n address_line2 = 'Sunset Town', email = 'sidchilling@gmail.com', \\n address_city = 'Boston', address_state = 'MA', address_country = 'US',\\n address_zip = '12345')\\n print address.to_dict()\",\n \"def test_address_other_parameters():\\n address = lob.Address.create(name='Siddharth Saha', address_line1='104, Printing Boulevard',\\n address_line2='Sunset Town', email='sidchilling@gmail.com',\\n address_city='Boston', address_state='MA', address_country='US',\\n address_zip='12345')\\n print address.to_dict()\",\n \"def toAddr(self, addressString: unicode) -> ghidra.program.model.address.Address:\\n ...\",\n \"def allocate_address():\\n response = EC2.allocate_address(\\n )\\n return response\",\n \"def test_create_new_address_with_permission(self):\\n data = dict(\\n address_line1='random address 2',\\n postal_code='RAN DOM',\\n city='random city',\\n state_province=self.random_state_province.iso_code,\\n country=self.random_country.iso_code,\\n )\\n\\n self.client.force_authenticate(user=self.admin)\\n\\n response = self.client.post(\\n reverse('location:addresses'),\\n data,\\n format='json',\\n )\\n\\n data['address_line2'] = ''\\n data['state_province'] = dict(\\n name=self.random_state_province.name,\\n iso_code=self.random_state_province.iso_code\\n )\\n data['country'] = dict(\\n name=self.random_country.name,\\n iso_code=self.random_country.iso_code\\n )\\n\\n res = json.loads(response.content)\\n del res['id']\\n\\n self.assertEqual(response.status_code, status.HTTP_201_CREATED)\\n self.assertEqual(res, data)\",\n \"def choose_new_address(self) -> \\\"CheckoutPage\\\":\\n self.accordion = BillingDetailsUser(self.driver)\\n self.accordion.btn_new_address.click()\\n return self\",\n \"def post(self, request, *args, **kwargs):\\n request_data = request.data\\n\\n # create address serializers object\\n serializer = self.serializer_class(data=request_data, context={'request': request})\\n\\n # check address serializers is valid\\n if not serializer.is_valid():\\n return APIResponse(serializer.errors, HTTP_400_BAD_REQUEST)\\n\\n validated_data = serializer.validated_data\\n\\n try:\\n # verified address\\n verifiedAddressRep = LobAddressVerification.verify_address(validated_data)\\n except Exception as err:\\n return APIResponse({\\\"message\\\": err.args[0]}, HTTP_400_BAD_REQUEST)\\n\\n print(\\\"======verifiedAddressRep=========\\\", verifiedAddressRep)\\n # get last transaction save point id\\n sid = transaction.savepoint()\\n\\n # try:\\n # # save admin address\\n # instance = serializer.create(validated_data)\\n # except Exception as err:\\n # logger.error(\\\"Unexpected error occurred : %s.\\\", err)\\n # # roll back transaction if any exception occur while add new address\\n # transaction.savepoint_rollback(sid)\\n # return APIResponse({\\\"message\\\": err.args[0]}, HTTP_400_BAD_REQUEST)\\n #\\n # # convert model object into json\\n # data = AddressViewSerializer(instance).data\\n # data['message'] = ADD_ADDRESS\\n\\n return APIResponse(\\\"data\\\", HTTP_201_CREATED)\",\n \"def get_or_create(self):\\n if self.is_valid():\\n address, created = Address.objects.get_or_create(\\n street=self.cleaned_data['street'],\\n city=self.cleaned_data['city'],\\n state=self.cleaned_data['state'],\\n country=self.cleaned_data['country'],\\n postal_code=self.cleaned_data['postal_code'],\\n )\\n return address\\n return None\",\n \"def add_address(self, address_list=None):\\n sql = u' INSERT INTO address_TBL ' \\\\\\n u'(line_1, line_2, city, county, country, billing_address, main_address, client_company_ID) ' \\\\\\n u'VALUES (%s, %s, %s, %s, %s, %s, %s, %s);'\\n if address_list is None:\\n address_list = self.data_set['address']\\n\\n c, conn = connection(self.schema)\\n\\n try:\\n for address in address_list:\\n if address['line_2'] is None:\\n address['line_2'] = 'NULL'\\n if address['billing'] is None:\\n address['billing'] = 0\\n if address['default'] is None:\\n address['default'] = 0\\n\\n data = (address['line_1'],\\n address['line_2'],\\n address['city'],\\n address['county'],\\n address['country'],\\n address['billing'],\\n address['default'],\\n self.id)\\n\\n c.execute(sql, data)\\n finally:\\n conn_close(c, conn)\",\n \"def address(self, new_address):\\n house_num, street_name, apt_num = new_address\\n self._address.house_num = house_num\\n self._address.street_name = street_name\\n self._address.apt_num = apt_num\",\n \"def do_charge_purchase_create(cs, args):\\n purchase = cs.charge_purchases.create(args.purchase_name)\\n utils.print_dict(purchase._info)\",\n \"def add_new_address(self, address: dict) -> None:\\n self.new_address_button.click()\\n\\n self.address_form.select_location(address['address'])\\n self.address_form.label_input.fill(address['name'])\\n\\n self.address_form.save_button.click()\",\n \"def as_address(self, base_clazz):\\n address = base_clazz()\\n address.name = self.name\\n address.line1 = self.line1\\n address.line2 = self.line2\\n address.city = self.city\\n address.region = self.region\\n address.country = self.country\\n address.post_code = self.post_code\\n address.phone = self.phone\\n return address\",\n \"def create_shop(shop_id, name, lat, lng, address_num=None, address_street=None, zipcode=None):\\n\\n shop = Shop(shop_id=shop_id, name=name, address_num=address_num, \\n address_street=address_street, zipcode=zipcode, lat=lat, lng=lng)\\n db.session.add(shop)\\n db.session.commit()\\n return shop\",\n \"def generate_address(self, private_key):\\n words, seed = CryptoUtils.create_mnemonic_key(private_key)\\n private_key_to_hex = CryptoUtils.generate_private_key(seed)\\n public_key = CryptoUtils.generate_public_key(private_key_to_hex)\\n public_key_compressed = CryptoUtils.compress_public_key(public_key)\\n address = CryptoUtils.generate_address(public_key)\\n self.addresses[address] = {\\n 'owner_key': private_key,\\n 'private_key': private_key_to_hex,\\n 'mnemonic_words': words,\\n 'public_key': public_key,\\n 'public_key_compressed': public_key_compressed,\\n 'balance': 0\\n }\",\n \"def test_new_empty_invoice_address(self):\\r\\n self.original = self.env[\\\"res.partner\\\"].create({\\r\\n \\\"is_company\\\": False,\\r\\n \\\"type\\\": 'invoice',\\r\\n \\\"lastname\\\": \\\"\\\",\\r\\n \\\"firstname\\\": \\\"\\\"})\",\n \"def save_object(self, data):\\n return Address(**data)\",\n \"def createAddressSet(self) -> ghidra.program.model.address.AddressSet:\\n ...\",\n \"def get_address(self, list_item):\\n Address = namedtuple('Address', ['addr', 'city', 'state', 'zip'])\\n extract = [text for text in list_item.find('address').stripped_strings]\\n\\n # Sometimes a street address is not given\\n if len(extract) == 1:\\n addr, rest = None, extract[0]\\n else:\\n addr, rest = extract\\n\\n city, rest = rest.split(',')\\n state, zip = rest.strip().split(' ')\\n return Address(addr, city, state, zip)\",\n \"def make_address_from_passphrase(passphrase, compressed=True, as_str=True):\\n if not isinstance(passphrase, bytes):\\n passphrase = bytes(passphrase, \\\"utf-8\\\")\\n passphrasehash = hashlib.sha256(passphrase).digest()\\n private_key = CBitcoinSecret.from_secret_bytes(passphrasehash, compressed=compressed)\\n address = P2PKHBitcoinAddress.from_pubkey(private_key.pub)\\n if as_str:\\n return str(address)\\n else:\\n return address\",\n \"def set_address(self, address):\\n if address == \\\"\\\":\\n self.address = Address(\\\"\\\", \\\"\\\", \\\"\\\")\\n else:\\n self.address = address\",\n \"def _generate_new_address(self) -> str:\\n while True:\\n address = \\\"0x\\\" + \\\"\\\".join([str(hex(randint(0, 16)))[-1] for _ in range(20)])\\n if address not in self.accounts.keys():\\n return address\",\n \"def add_addressitem(self, addressitem):\\n self.addresses.append(addressitem)\",\n \"def _addressitem_from_line(line):\\n sline = line.split(\\\"\\\\t\\\")\\n if len(sline) < 2:\\n raise IOError(\\\"Error parsing address from line. Malformed data.\\\")\\n address = sline[0]\\n name = sline[1]\\n\\n if len(sline) > 2:\\n otherinfo = sline[2]\\n else:\\n otherinfo = \\\"\\\"\\n if len(sline) > 3:\\n extrainfo = sline[3]\\n else:\\n extrainfo = \\\"\\\"\\n if len(sline) > 4:\\n raw_misc = sline[4:]\\n misc = _raw_misc_to_dict(raw_misc)\\n else:\\n misc = {}\\n\\n return AddressItem(\\n _email_address=address,\\n _name=name,\\n _otherinfo=otherinfo,\\n _extrainfo=extrainfo,\\n **misc\\n )\",\n \"def test_get_order_address(self):\\n pass\",\n \"def deposit_address(self):\\n response = self.query('deposit_address')\\n return response\",\n \"def add_address(self, address_item):\\r\\n self.addresses_to_validate.append(address_item)\",\n \"def do_addresses(self, args):\\n pprint(self.wallet.addresses)\",\n \"def on_GenerateRandomAccountAddress_clicked(self):\\n # TODO: not implemented yet\\n raise NotImplementedError\",\n \"def create_supplier(name: str, short_name: str, address: str) -> Supplier:\\n return Supplier(name, short_name, address)\",\n \"def generate_address(rpc_user, rpc_pwd, observer):\\n data = ('{\\\"jsonrpc\\\":\\\"2.0\\\",\\\"id\\\":\\\"1\\\",\\\"method\\\":\\\"getnewaddress\\\",' +\\n '\\\"params\\\":[\\\"Observer\\\"]}'.replace('Observer', observer))\\n return call_rpc(rpc_user, rpc_pwd, data)\",\n \"def get_address(self):\\n\\n return \\\"{}\\\\n{}\\\\n{},\\\\n{},\\\\n{}\\\".format(\\n self.address_line_1, self.city, self.state, self.postal_code, self.country\\n )\",\n \"def purchase_ip(self, debug=False):\\n json_scheme = self.gen_def_json_scheme('SetPurchaseIpAddress')\\n json_obj = self.call_method_post(method='SetPurchaseIpAddress', json_scheme=json_scheme, debug=debug)\\n try:\\n ip = Ip()\\n ip.ip_addr = json_obj['Value']['Value']\\n ip.resid = json_obj['Value']['ResourceId']\\n return ip\\n except:\\n raise Exception('Unknown error retrieving IP.')\",\n \"def test_create_address(self): \\n url = reverse('v1:addresses-list', args=[1])\\n profile = ProfileFactory.create()\\n \\n address_data = {'profile' : str(profile.id),\\n 'street_address' : 'test street',\\n 'city' : 'test city',\\n 'state' : 'test state', \\n 'zip_code' : 'test zip',\\n 'country' : 'test country',\\n }\\n\\n # Check Anonymous User should return 403\\n response = self.client.post(url, address_data, format='json')\\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)\\n\\n # Profile Owner User\\n self.client.credentials(Authorization='Bearer ' + 'regularusertoken')\\n response = self.client.post(url, address_data, format='json')\\n response_data = response.json()\\n self.assertEqual(response.status_code, status.HTTP_201_CREATED)\\n \\n self.assertIsNotNone(response_data[\\\"profile\\\"])\\n self.assertEqual(ProfileAddress.objects.get(profile=response_data['profile']).street_address, 'test street')\\n self.assertEqual(ProfileAddress.objects.get(profile=response_data['profile']).city, address_data['city'])\\n self.assertEqual(len(ProfileAddress.objects.all()), 1)\\n self.assertEqual(Profile.objects.get(pk=profile.id).id, uuid.UUID(response_data['profile']))\",\n \"def address(self):\\n return str(self.street) + str(self.city) + str(self.state) + str(self.zipcode)\",\n \"def test_to_address(mocker):\\n transaction = Transaction(\\n chain=1,\\n nonce=10,\\n fee=50,\\n value=5_000_000,\\n to_address=\\\"1H7NtUENrEbwSVm52fHePzBnu4W3bCqimP\\\",\\n unlock_sig=Config.COINBASE_UNLOCK_SIGNATURE,\\n )\\n\\n assert transaction.validate() == True\\n assert transaction.validate(raise_exception=True) == True\\n\\n transaction.to_address = \\\"1H7NtUENrEbwSVm52fHePzBnu4W3bCqimPX\\\"\\n assert transaction.validate() == False\\n with pytest.raises(\\n TransactionNotValid, match=errors.TRANSACTION_FIELD_TO_ADDRESS\\n ):\\n transaction.validate(raise_exception=True)\",\n \"def getNewAddress(self):\\n a = self.selectedAccount.getNextPaymentAddress()\\n if self.blockchain:\\n self.blockchain.subscribeAddresses(a)\\n self.save()\\n return a\",\n \"def choose_new_address_delivery(self) -> \\\"CheckoutPage\\\":\\n self.accordion = DeliveryDetailsUser(self.driver)\\n self.accordion.btn_new_address_delivery.click()\\n return self\",\n \"def ship_to_pickup_address(self, address):\\n self._set('shipping', 'pickup_address_id', address.id)\",\n \"def generate_address(self, meta, network: int) -> Address:\\n raise NotImplemented\",\n \"def set_address(self, new_address, ):\\n self.address.append(new_address)\\n self.save()\",\n \"def make_address(pubkeys, n):\\n return (str(len(pubkeys)) + str(n) +\\n base58_encode(det_hash({str(n): pubkeys}))[0:29])\",\n \"def post(self):\\n return self.get_request_handler(request.headers).create_new_address(request)\",\n \"def store_address(intent, session):\\n sess_data = session.setdefault('attributes', {})\\n if not sess_data.get('add_address') and \\\\\\n not sess_data['next_step'] == 'store_address':\\n raise RuntimeError('Something went wrong.')\\n\\n data = {sess_data['which']: dict(latitude=str(sess_data['latitude']),\\n longitude=str(sess_data['longitude']),\\n address=str(sess_data['full_address']))}\\n success = database.update_user_data(session['user']['userId'], **data)\\n if not success:\\n return reply.build(\\\"I'm sorry, something went wrong and I could't \\\"\\n \\\"store the address.\\\", is_end=True)\\n else:\\n return reply.build(\\\"Okay, I've saved your %s \\\"\\n \\\"address.\\\" % sess_data['which'],\\n is_end=True)\",\n \"def do_getaddress(self,args):\\n ppdict(bitstamp.get_depositaddress())\",\n \"def create_addressbook(parent, name, title=None):\\n ab = icemac.addressbook.utils.create_obj(\\n icemac.addressbook.addressbook.AddressBook)\\n if title is not None:\\n ab.title = title\\n parent[name] = ab\\n return ab\",\n \"def generate_address_randomKey(self):\\n private_key = CryptoUtils.generate_random_private_key()\\n self.generate_address(private_key)\",\n \"def createBilling(self, loginName, password, data):\\n return self.talk('purchase',\\n data=self.__makeLoginDict(loginName, password, data))\",\n \"def address(self, address: object):\\n\\n self._address = address\",\n \"def createSymbol(self, address: ghidra.program.model.address.Address, name: unicode, makePrimary: bool) -> ghidra.program.model.symbol.Symbol:\\n ...\",\n \"def record_purchase(params, order):\\r\\n ccnum_str = params.get('card_accountNumber', '')\\r\\n m = re.search(\\\"\\\\d\\\", ccnum_str)\\r\\n if m:\\r\\n ccnum = ccnum_str[m.start():]\\r\\n else:\\r\\n ccnum = \\\"####\\\"\\r\\n\\r\\n order.purchase(\\r\\n first=params.get('billTo_firstName', ''),\\r\\n last=params.get('billTo_lastName', ''),\\r\\n street1=params.get('billTo_street1', ''),\\r\\n street2=params.get('billTo_street2', ''),\\r\\n city=params.get('billTo_city', ''),\\r\\n state=params.get('billTo_state', ''),\\r\\n country=params.get('billTo_country', ''),\\r\\n postalcode=params.get('billTo_postalCode', ''),\\r\\n ccnum=ccnum,\\r\\n cardtype=CARDTYPE_MAP[params.get('card_cardType', 'UNKNOWN')],\\r\\n processor_reply_dump=json.dumps(params)\\r\\n )\",\n \"def test_create_email_address(self):\\n email_addr = 'testcreate@' + self.email_dom\\n org = 'o=%s' % (self.org_name)\\n people = '%s=%s' % (self.container_attr, self.user_container)\\n uid = '%s=%s' % (self.user_key, self.user_id)\\n dn = '%s,%s,%s,%s' % (uid, people, org, self.base_dn)\\n dn_info = {self.smtp_address: [email_addr]}\\n expected_result = [(dn, dn_info)] \\n addr = SpokeEmailAddress(self.org_name, self.user_id)\\n result = addr.create(email_addr)['data']\\n self.assertEqual(result, expected_result)\",\n \"def type_address(self, address):\\n\\n\\t\\twith allure.step(\\\"Type payee address\\\"):\\n\\t\\t\\telement = Element(driver=self.driver,\\n\\t\\t\\t explicit_wait_time=self.explicit_wait_time,\\n\\t\\t\\t locator=BillPayPageLocator.ADDRESS_INPUT)\\n\\t\\t\\telement.write(address)\\n\\t\\t\\treturn None\",\n \"def toAddr(self, offset: int) -> ghidra.program.model.address.Address:\\n ...\",\n \"def address():\\n # We start with generating the street name. For this we choose\\n # between the most common prefixes and our own prefixes\\n prefix = dice.randint(1, 100)\\n if prefix <= 10: # 10%\\n prefix = \\\"Haupt\\\"\\n elif prefix <= 18: # 8%\\n prefix = \\\"Schul\\\"\\n elif prefix <= 25: # 7%\\n prefix = \\\"Garten\\\"\\n elif prefix <= 32: # 7%\\n prefix = \\\"Dorf\\\"\\n elif prefix <= 39: # 7%\\n prefix = \\\"Bahnhof\\\"\\n elif prefix <= 46: # 7%\\n prefix = \\\"Wiesen\\\"\\n elif prefix <= 52: # 6%\\n prefix = \\\"Berg\\\"\\n elif prefix <= 56: # 4%\\n prefix = \\\"Kirch\\\"\\n elif prefix <= 60: # 4%\\n prefix = \\\"Wald\\\"\\n elif prefix <= 64: # 4%\\n prefix = \\\"Ring\\\"\\n else:\\n prefix = dice.choice(names.prefix)\\n\\n # Now we can add the suffix\\n suffix = dice.randint(1, 100)\\n if suffix <= 78:\\n suffix = \\\"straße\\\"\\n elif suffix <= 96:\\n suffix = \\\"weg\\\"\\n elif suffix <= 98:\\n suffix = \\\"allee\\\"\\n elif suffix == 99:\\n suffix = \\\"ring\\\"\\n elif suffix == 100:\\n suffix = \\\"platz\\\"\\n\\n # When we have a city name as prefix, we need to capitalize the\\n # suffix since it will be two words\\n if prefix[-1] == \\\" \\\":\\n suffix = suffix.capitalize()\\n\\n # Now we can add them together\\n street = prefix + suffix\\n\\n # We need a house number as well. In Germany most numbers have\\n # between one and four digits, so we will use this as base. Lower\\n # numbers are more common, so we'll give it a 10% probability of\\n # using 3 digits and 1% of using 4 digits\\n digits = dice.randint(1, 100)\\n if digits == 100:\\n house_number = str(dice.randint(1000, 9999))\\n elif digits >= 90:\\n house_number = str(dice.randint(100, 999))\\n else:\\n house_number = str(dice.randint(1, 99))\\n address_full = street + \\\" \\\" + house_number\\n return address_full\",\n \"def on_GenerateRandomAccountAddress_2_clicked(self):\\n # TODO: not implemented yet\\n raise NotImplementedError\",\n \"def create_and_verify(cls, api_key: Optional[str] = None, **params) -> \\\"Address\\\":\\n requestor = Requestor(local_api_key=api_key)\\n url = \\\"%s/%s\\\" % (cls.class_url(), \\\"create_and_verify\\\")\\n\\n wrapped_params = {cls.snakecase_name(): params}\\n response, api_key = requestor.request(method=RequestMethod.POST, url=url, params=wrapped_params)\\n\\n return convert_to_easypost_object(response=response[\\\"address\\\"], api_key=api_key)\",\n \"def get_new_address(self):\\n key = generate_key(generate_random())\\n address = pubtoaddr(key[\\\"public\\\"])\\n self.keyring.append(key)\\n write_keys(self.path, self.keyring)\\n return address\",\n \"def create_order(self, openid, **kwargs):\\n data = kwargs\\n data['openid'] = openid\\n\\n self._check_create_order(**data)\\n\\n order_data = {\\n 'appid': self.appid,\\n 'mch_id': self.mch_id,\\n 'nonce_str': uuid.uuid4().hex,\\n 'body': kwargs.get('title'),\\n 'out_trade_no': kwargs.get('order_uid'),\\n 'total_fee': int(kwargs.get('total') * 100),\\n 'notify_url': kwargs.get('notify_url'),\\n 'spbill_create_ip': kwargs.get('ip'),\\n 'trade_type': kwargs.get('trade_type')\\n }\\n fields = ('detail', 'time_expire', 'time_start', 'openid',\\n 'product_id')\\n for field in fields:\\n if field in kwargs:\\n order_data[field] = kwargs[field]\\n\\n return self.send_data(self.UNIFIED_ORDER_URL, **order_data)\",\n \"def getnewaddress(self):\\n passphrase = self._getnewaddress_passphrase_template.format(self._getnewaddress_offset)\\n address = make_address_from_passphrase(bytes(passphrase, \\\"utf-8\\\"))\\n self._getnewaddress_offset += 1\\n return CBitcoinAddress(address)\",\n \"def getnewaddress(self, account=None):\\n if account is None:\\n return self.proxy.getnewaddress()\\n else:\\n return self.proxy.getnewaddress(account)\",\n \"def save(self, *args, **kwargs):\\n # Save a hash of the address fields so we can check whether two\\n # addresses are the same to avoid saving duplicates\\n # self.hash = self.generate_hash()\\n\\n # Ensure that each user only has one default shipping address\\n # and billing address\\n self._ensure_defaults_integrity()\\n super(UserAddress, self).save(*args, **kwargs)\",\n \"def test_get_shipping_address(self):\\n self.cim.get_shipping_address(\\n customer_profile_id=u\\\"900\\\",\\n customer_address_id=u\\\"344\\\"\\n )\",\n \"def main(options):\\n home = Address(options.name,\\n options.address,\\n options.city,\\n options.state,\\n options.zip_code)\",\n \"def create_order(self, serializer):\\n data = serializer.validated_data\\n service: Service = data['service']\\n customer: Customer = Customer.objects.get_or_create(\\n email=data['email'])[0]\\n invoice: Invoice = Invoice(\\n charged_amount=service.price.amount,\\n currency=service.price.currency,\\n timestamp=now(),\\n customer=customer,\\n service=service\\n )\\n invoice.save()\\n serializer.validated_data['invoice_id'] = invoice.id\\n serializer.save()\\n\\n self.send_order_email(invoice, serializer.instance)\",\n \"def address(self, address: str):\\n\\n self._address = address\",\n \"def GenerateAddressBook(self, node):\\n if not self.addressbook:\\n return\\n addrs = Tree('addresses')\\n addrs.AddParent(node)\\n index=0\\n for zone in self.addressbook:\\n # building individual addresses\\n groups = sorted(self.addressbook[zone])\\n for group in groups:\\n ips = nacaddr.SortAddrList(self.addressbook[zone][group])\\n ips = nacaddr.CollapseAddrList(ips)\\n self.addressbook[zone][group] = ips\\n count = index + 0\\n for address in self.addressbook[zone][group]:\\n prefix_type = 'ipv4-prefix '\\n if isinstance( address, nacaddr.IPv6):\\n prefix_type = 'ipv6-prefix '\\n addr_list = Tree('address'+' _' + group, prefix_type +\\n ' ' + str(address) + ';')\\n addr_list.AddParent(addrs)\\n count += 1\\n index += count\\n\\n addr_groups=Tree('address-groups')\\n addr_groups.AddParent(node)\\n for zone in self.addressbook:\\n # building address-sets\\n addrlist = ''\\n for group in self.addressbook[zone]:\\n addrlist = addrlist + '_' + group + ' '\\n group_t=Tree('group ' + zone, 'address-list [ ' + addrlist + '];')\\n group_t.AddParent(addr_groups)\",\n \"def _unique_address(self, **kwargs):\\n pass\",\n \"def toAddr(self, offset: long) -> ghidra.program.model.address.Address:\\n ...\",\n \"def CreateCustomer(Person):\\n\\t\\t\\tif Person.AddrCitytownNrID:\\n\\t\\t\\t\\tcitytown = model.AddressCityTown.get(Person.AddrCitytownNrID)\\n\\t\\t\\t\\tAddressLabel = '%s\\\\n%s\\\\n%s, %s\\\\n%s\\\\n%s' % (Person.AddrStr, citytown.Name, citytown.Block, citytown.District, citytown.State, citytown.ZipCode) \\n\\t\\t\\telse:\\n\\t\\t\\t\\tAddressLabel = Person.AddrStr\\n\\t\\t\\tPersonName = ('%s %s,%s,%s' % (Person.Title, Person.NameFirst, Person.NameMiddle, Person.NameLast)).replace(',,',',').replace(',', ' ').strip()\\n\\t\\t\\tcustomer = model.InvCustomer(Name=PersonName ,CityID=Person.AddrCitytownNrID , AddressLabel=AddressLabel, CreditAmount=0.0, \\\\\\n\\t\\t\\t\\tInventoryLocation=self.GetDefaultCustomerLocationID(), ExternalID=Person.id)\\n\\t\\t\\treturn customer\",\n \"def get_apartment_address(self, soup, apartment_dict):\\n\\n info_class = soup.find_all('div', {'class': 'info'})\\n if info_class and len(info_class) > 0:\\n info_class = info_class[0]\\n address = info_class.find('h2').text.strip()\\n\\n from parse import parse\\n address = parse(\\\"Location: {}\\\", address)[0]\\n apartment_dict['address'] = address\\n else:\\n logging.warning(\\\"Failed to parse apartment address\\\")\\n return\",\n \"def _set_address(self, v, load=False):\\n try:\\n t = YANGDynClass(v,base=[unicode,unicode,unicode,unicode,unicode,], is_leaf=True, yang_name=\\\"address\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True)\\n except (TypeError, ValueError):\\n raise ValueError(\\\"\\\"\\\"address must be of a type compatible with base=[unicode,unicode,unicode,unicode,unicode,], is_leaf=True, yang_name=\\\"address\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True\\\"\\\"\\\")\\n self.__address = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def getAddressAtIndex(self, index: int) -> ghidra.program.model.address.Address:\\n ...\",\n \"def street_address():\\r\\n\\r\\n return _random.choice(\\r\\n [\\r\\n '%d-%d %s' % (\\r\\n _random.randrange(999),\\r\\n _random.randrange(999),\\r\\n street_name()\\r\\n ),\\r\\n '%d %s' % (\\r\\n _random.randrange(999),\\r\\n street_name()\\r\\n ),\\r\\n '%s %d, %s' % (\\r\\n 'P.O. Box',\\r\\n _random.randrange(999),\\r\\n street_name()\\r\\n )\\r\\n ]\\r\\n )\",\n \"def createSymbol(self, address: ghidra.program.model.address.Address, name: unicode, makePrimary: bool, makeUnique: bool, sourceType: ghidra.program.model.symbol.SourceType) -> ghidra.program.model.symbol.Symbol:\\n ...\",\n \"def set_address(self, address):\\n pass\",\n \"def nameToAddress(self, name):\\n pass\",\n \"def create(self, values):\\n if values.get('name', _('New')) == _('New'):\\n values['name'] = self.env['ir.sequence'].next_by_code('order.reference',\\n None) or _('New')\\n values['marks'] = values['name']\\n customer_code = ''\\n if values.get('customer_id'):\\n customer = self.env['res.partner'].browse(values.get('customer_id'))\\n customer_code = customer.customer_code\\n if values.get('marks'):\\n marks_field = values.get('marks')\\n else:\\n marks_field = ' '\\n\\n values['marks'] = '%s %s %s' % (customer_code, values['name'], marks_field)\\n return super(PurchaseOrder, self).create(values)\",\n \"def add_merchant(street, merchant):\\r\\n street.append(merchant)\",\n \"def get_postal_address(self):\\n # print \\\"getting postal address\\\"\\n address = []\\n if self.name:\\n address.append(self.name)\\n if self.number:\\n address.append(self.number + \\\" \\\" + self.street) # because building numbers and street names go on the same line\\n elif self.street:\\n address.append(self.street)\\n if self.additional_street_address:\\n address.append(self.additional_street_address)\\n if self.site.post_town:\\n address.append(self.site.post_town + \\\" \\\" + self.postcode)\\n elif self.postcode:\\n address.append(self.postcode)\\n return address\",\n \"def test_update_shipping_address(self):\\n self.cim.update_shipping_address(\\n customer_profile_id=u\\\"222\\\",\\n customer_address_id=u\\\"444\\\",\\n first_name=u\\\"pippo\\\",\\n phone=u\\\"415-415-4154\\\"\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73644215","0.7143773","0.7031508","0.6538616","0.64551836","0.64361376","0.64270854","0.6425408","0.6418397","0.63918406","0.6356949","0.62770784","0.6219692","0.62043613","0.6161881","0.6076241","0.6072444","0.6055833","0.6051252","0.60130686","0.5984363","0.59607756","0.5895233","0.58858687","0.58701277","0.5865807","0.58429813","0.58206683","0.57969975","0.57869285","0.5752346","0.5716496","0.5709181","0.56973463","0.5680993","0.56556123","0.56394076","0.5629896","0.56239563","0.56201404","0.5611761","0.5574877","0.55649084","0.55361176","0.5522699","0.54983085","0.548855","0.5482561","0.54788256","0.54783267","0.5459816","0.5426951","0.54148775","0.53973794","0.53894407","0.53783876","0.5377261","0.53753436","0.53706115","0.5366586","0.5361","0.53517264","0.53452605","0.533398","0.5332094","0.5310282","0.5300051","0.52990335","0.52962005","0.52930444","0.5286484","0.5281345","0.52781856","0.5276011","0.52759326","0.52737105","0.5273353","0.52652955","0.5260529","0.5259488","0.5249801","0.52421945","0.52405083","0.52370656","0.5227889","0.5226721","0.5217661","0.52167886","0.52065593","0.51979846","0.5190625","0.51840967","0.51823974","0.5180316","0.518025","0.51755834","0.5166979","0.5165322","0.51625866","0.51501405","0.5149846"],"string":"[\n \"0.73644215\",\n \"0.7143773\",\n \"0.7031508\",\n \"0.6538616\",\n \"0.64551836\",\n \"0.64361376\",\n \"0.64270854\",\n \"0.6425408\",\n \"0.6418397\",\n \"0.63918406\",\n \"0.6356949\",\n \"0.62770784\",\n \"0.6219692\",\n \"0.62043613\",\n \"0.6161881\",\n \"0.6076241\",\n \"0.6072444\",\n \"0.6055833\",\n \"0.6051252\",\n \"0.60130686\",\n \"0.5984363\",\n \"0.59607756\",\n \"0.5895233\",\n \"0.58858687\",\n \"0.58701277\",\n \"0.5865807\",\n \"0.58429813\",\n \"0.58206683\",\n \"0.57969975\",\n \"0.57869285\",\n \"0.5752346\",\n \"0.5716496\",\n \"0.5709181\",\n \"0.56973463\",\n \"0.5680993\",\n \"0.56556123\",\n \"0.56394076\",\n \"0.5629896\",\n \"0.56239563\",\n \"0.56201404\",\n \"0.5611761\",\n \"0.5574877\",\n \"0.55649084\",\n \"0.55361176\",\n \"0.5522699\",\n \"0.54983085\",\n \"0.548855\",\n \"0.5482561\",\n \"0.54788256\",\n \"0.54783267\",\n \"0.5459816\",\n \"0.5426951\",\n \"0.54148775\",\n \"0.53973794\",\n \"0.53894407\",\n \"0.53783876\",\n \"0.5377261\",\n \"0.53753436\",\n \"0.53706115\",\n \"0.5366586\",\n \"0.5361\",\n \"0.53517264\",\n \"0.53452605\",\n \"0.533398\",\n \"0.5332094\",\n \"0.5310282\",\n \"0.5300051\",\n \"0.52990335\",\n \"0.52962005\",\n \"0.52930444\",\n \"0.5286484\",\n \"0.5281345\",\n \"0.52781856\",\n \"0.5276011\",\n \"0.52759326\",\n \"0.52737105\",\n \"0.5273353\",\n \"0.52652955\",\n \"0.5260529\",\n \"0.5259488\",\n \"0.5249801\",\n \"0.52421945\",\n \"0.52405083\",\n \"0.52370656\",\n \"0.5227889\",\n \"0.5226721\",\n \"0.5217661\",\n \"0.52167886\",\n \"0.52065593\",\n \"0.51979846\",\n \"0.5190625\",\n \"0.51840967\",\n \"0.51823974\",\n \"0.5180316\",\n \"0.518025\",\n \"0.51755834\",\n \"0.5166979\",\n \"0.5165322\",\n \"0.51625866\",\n \"0.51501405\",\n \"0.5149846\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24596,"cells":{"query":{"kind":"string","value":"Given a vehicle and its current visiting customer, return the next visiting customer. Here we use the Timeoriented NearestNeighborhood Heuristic proposed by Solomon(1987)."},"document":{"kind":"string","value":"def time_nn(self, on_way_time, curr_cust, remain_list, used_resource, rout_len, vehicle_type):\r\n if vehicle_type == 2:\r\n veh_cap = small_veh\r\n elif vehicle_type == 3:\r\n veh_cap = medium_veh\r\n else:\r\n veh_cap = large_veh\r\n real_wait_time = 0 # the final wait time after testing all the possible stores\r\n real_vst_cust = -1 # the final visiting store after testing all the possible stores\r\n visit_cust = [-1, 100000, 600000, 10000] # [cust_id, next_start, distance, closeness]\r\n if rout_len - 1 < 50: # max number of stores a vehicle visits\r\n for cust in remain_list:\r\n # print('checking customer: ', cust)\r\n if (used_resource[0] + num_demd[cust][0] * bskt_vol + num_demd[cust][1] * trsf_vol + (num_demd[cust][2] +\r\n num_demd[cust][3]) * milk_vol + num_demd[cust][4] * paper_bskt) > veh_cap[2]:\r\n # print('run out of effective volume')\r\n continue # volume overload\r\n # elif dist_mat[curr_cust, cust] + dist_mat[cust, 0] > veh_cap[3] - used_resource[3]:\r\n # print('run out of distance')\r\n # continue\r\n elif used_resource[2] + time_mat[curr_cust, cust] > num_timez[cust][1]:\r\n # print('late than last receive time')\r\n continue # can not arrive before last receive time\r\n elif time_mat[curr_cust, cust] + oprt_t + time_mat[cust, 0] > veh_cap[3] - on_way_time:\r\n # print('run out of work time')\r\n continue\r\n elif (curr_cust > 0 and used_resource[2] + time_mat[curr_cust, cust] < num_timez[cust][0] and\r\n num_timez[cust][0] - used_resource[2] + oprt_t + time_mat[cust, 0] > veh_cap[3] - on_way_time):\r\n # print('run out of work time - with waiting time')\r\n continue\r\n else:\r\n wait_time = num_timez[cust][0] - (used_resource[2] + time_mat[curr_cust, cust])\r\n\r\n if wait_time < 0:\r\n next_start = used_resource[2] + time_mat[curr_cust, cust]\r\n h_ij = time_mat[curr_cust, cust]\r\n else: # arrive early\r\n next_start = num_timez[cust][0]\r\n if curr_cust == 0:\r\n h_ij = time_mat[curr_cust, cust]\r\n wait_time = 0 # special situation for depot depart\r\n else:\r\n h_ij = next_start - used_resource[2]\r\n v_ij = num_timez[cust][1] - (used_resource[2] + time_mat[curr_cust, cust])\r\n close_ij = alp * time_mat[curr_cust, cust] + bet * h_ij + gam * v_ij # closeness between i and j\r\n # print(curr_cust, cust, close_ij)\r\n if close_ij < visit_cust[3]:\r\n real_wait_time = wait_time\r\n real_vst_cust = cust\r\n visit_cust[0] = cust\r\n visit_cust[1] = next_start\r\n visit_cust[2] = dist_mat[curr_cust, cust]\r\n visit_cust[3] = close_ij\r\n else:\r\n continue\r\n\r\n\r\n if visit_cust[0] == -1: # no customer to visit\r\n visit_cust[0] = 0\r\n visit_cust[1] = used_resource[-1] + time_mat[curr_cust, 0]\r\n on_way_time += time_mat[curr_cust, 0]\r\n else:\r\n # print(curr_cust, real_vst_cust, real_wait_time)\r\n if real_wait_time <= 0:\r\n on_way_time += (oprt_t + time_mat[curr_cust, real_vst_cust])\r\n else:\r\n on_way_time += (oprt_t + real_wait_time + time_mat[curr_cust, real_vst_cust])\r\n\r\n return visit_cust, on_way_time"},"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 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 create_single_customer_route(customer: int) -> Route:\n problem = Problem()\n\n # After depot, and after customer: two configurations in total.\n stacks = [Stacks(problem.num_stacks) for _ in range(2)]\n\n # We place the deliveries and pickups in the shortest stack - this\n # does not really matter much, as each stack is empty at this point\n # anyway.\n stacks[0].shortest_stack().push_rear(problem.demands[customer])\n stacks[1].shortest_stack().push_rear(problem.pickups[customer])\n\n return Route([customer], stacks)","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 get_known_customer(name: str, address: str, customers: List[Customer], visit: bool=True) -> Optional[Customer]:\n\n for customer in customers:\n if customer.name == name and customer.address == address:\n customer.visit = visit\n return customer\n \n # No such customer found.\n return None","def heuristic_function(self, node_current: PriorityNode) -> float:\n ########################################################################\n # todo: Implement your own heuristic cost calculation here. #\n # Hint: #\n # Use the State of the current node and the information from the #\n # planning problem, as well as from the scenario. #\n # Some helper functions for your convenience can be found in #\n # ./search_algorithms/base_class.py #\n ########################################################################\n output_logs = False\n if output_logs:\n print(\"##################\")\n print(\"current time step: \", node_current.list_paths[-1][-1].time_step)\n print(\"current problem mode\", self.planningProblemType)\n print(\"depth tree: \", node_current.depth_tree)\n currentorient = node_current.list_paths[-1][-1].orientation\n currentpos = node_current.list_paths[-1][-1].position\n currenttimestep = node_current.list_paths[-1][-1].time_step\n currentVel = node_current.list_paths[-1][-1].velocity\n\n # Test if reached goal:\n if self.reached_goal(node_current.list_paths[-1]):\n return 0.0\n # Test if route planner failed to find a path: \n if self.routeplannerresult is None:\n return np.inf\n\n ############ Detect cars in front:\n # calc cost based on distance to gool following the refrence path:\n # loop through all obstacles at time step x and find if any is close of current pos:\n if not self.disableObstAvoidance:\n for obst in self.list_obstacles:\n obstPos = obst.state_at_time(currenttimestep)\n if currentorient is not None and obstPos is not None:\n disttoobst = self.euclidean_distance(currentpos, obstPos.position)\n lookaheadVar = 1.375 * currentVel + 2.5\n if disttoobst <= lookaheadVar:\n # calc orientation diff between car and obstacle:\n vectorToObst = np.array([currentpos, obstPos.position])\n vectorToObstOrient = self.calc_angle_of_position(vectorToObst, currentpos)\n orientdiff = self.calc_orientation_diff(currentorient, vectorToObstOrient)\n if abs(orientdiff) <= 0.261799:\n if not 'velocity' in obstPos.attributes:\n continue\n if node_current.list_paths[-1][-1].velocity > obstPos.velocity and obstPos.velocity != 0:\n return np.inf\n \n # get index of closest object to the ego vehicle:\n index_smallest_dist = self.get_index_nearest_obst_infront(node_current)\n \n # use the index to locate vehicle to calc cost: \n if index_smallest_dist != -1:\n # found the index of vehicle with smallest distance to ego car:\n obst = self.list_obstacles[index_smallest_dist]\n obstPos = obst.state_at_time(currenttimestep)\n if obstPos is not None and 'velocity' in obstPos.attributes:\n if obstPos.velocity == 0:\n cost = node_current.list_paths[-1][-1].velocity\n return cost\n if node_current.list_paths[-1][-1].velocity > obstPos.velocity:\n return np.inf\n cost = abs(node_current.list_paths[-1][-1].velocity - obstPos.velocity)\n return cost\n #########################################################\n\n # Decide based on planning problem type how to calculate cost\n if self.planningProblemType == 'ModeA':\n # Call function for planning problem with desired time, position, speed and orientation\n cost = self.cost_for_modeA_problem(node_current, output_logs)\n if output_logs:\n print(\"Cost from modeA cost func: \", cost)\n if cost < 0:\n return 0\n return cost\n elif self.planningProblemType == 'ModeB':\n # Call function for planning problem with desired time, position and velocity:\n cost = self.cost_for_modeB_problem(node_current, output_logs)\n if output_logs:\n print(\"Cost from modeB cost func: \", cost)\n if cost < 0:\n return 0\n return cost\n elif self.planningProblemType == 'ModeC':\n # Call function for planning problem with desired time, position and orientation:\n cost = self.cost_for_modeC_problem(node_current, output_logs)\n if output_logs:\n print(\"Cost from modeB cost func: \", cost)\n if cost < 0:\n return 0\n return cost\n elif self.planningProblemType == 'ModeD':\n # Call function for planning problem with desired time and position:\n cost = self.cost_for_modeD_problem(node_current, output_logs)\n if output_logs:\n print(\"Cost from modeB cost func: \", cost)\n if cost < 0:\n return 0\n return cost\n elif self.planningProblemType == 'Survival':\n # Call function for planning problem with desired time:\n cost = self.cost_for_Survival_problem(node_current, output_logs)\n if output_logs:\n print(\"Cost from modeB cost func: \", cost)\n if cost < 0:\n return 0\n return cost","def solve(customerCount, vehicleCount, vehicleCapacity, depotIndex, customers):\n \n N, locations, locations_r, distances, closest = precalculate(customers)\n \n #print locations\n #print locations_r\n angle_order = range(1, N)\n angle_order.sort(key=lambda i: (locations_r[i, 1], locations_r[i, 0])) \n \n vehicleTours = best_order(customerCount, customers, vehicleCount, vehicleCapacity, angle_order)\n if not vehicleTours:\n vehicleTours = solve0(customerCount, vehicleCount, vehicleCapacity, depotIndex, customers)\n check(customerCount, customers, vehicleCapacity, vehicleTours)\n vehicleTours = get_shortest_paths('file_path XXX', customers, depotIndex, vehicleTours)\n check(customerCount, customers, vehicleCapacity, vehicleTours)\n \n vehicleTours0 = copy.deepcopy(vehicleTours)\n dist0 = total_dist(customers, depotIndex, vehicleTours)\n if False:\n for _ in range(100):\n vehicleTours = copy.deepcopy(vehicleTours0) \n adjust_tours(customers, vehicleCapacity, vehicleCount, vehicleTours)\n vehicleTours = get_shortest_paths('file_path XXX', customers, depotIndex, vehicleTours)\n #check(customerCount, customers, vehicleCapacity, vehicleTours)\n if not is_valid(customerCount, customers, vehicleCapacity, vehicleTours):\n continue\n dist = total_dist(customers, depotIndex, vehicleTours)\n if dist < dist0:\n print '%s => %s' % (dist0, dist)\n vehicleTours0 = vehicleTours[:]\n dist0 = dist\n \n \n vehicleTours = copy.deepcopy(vehicleTours0) \n check(customerCount, customers, vehicleCapacity, vehicleTours)\n while len(vehicleTours) < vehicleCount:\n vehicleTours.append([])\n \n print '*', vehicleTours \n \n return vehicleTours","def determineNextMove(playerLocation, opponentLocation, coins):\n global packages, route_table, best_path, best_weight, route\n if len(best_path) == 0:\n current_package = packages.pop(0)\n exhaustive(current_package, playerLocation, [], 0, (route_table,dists))\n api.debug(best_path)\n return u.direction(playerLocation, best_path.pop(0))","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 next_car(schedule, travel_time):\n\n #travel_time = datetime.datetime.strptime(datetime.datetime.strptime(travel_time, '%Y-%m-%d %H:%M:%S').strftime('%H:%M:%S'), '%H:%M:%S')\n next_time = None\n\n for index, time in enumerate(schedule):\n if time.is_after(travel_time):\n next_time = index\n break\n #time = datetime.datetime.strptime(time, '%H:%M:%S')\n ## total_seconds is negative if travel_time is upper than time in schedule\n ## if its possible to get car when arrived at the same time it go to next stop\n ## just use >= instead of >\n #if (time - travel_time).total_seconds() > 0:\n ##print('SÉÉ:', time.__class__, time)\n ##print('SÉÉ:', travel_time.__class__, travel_time)\n ##print(time - travel_time)\n ##print('AUI:', travel_time - time, (travel_time - time).total_seconds())\n ##print('RET:', time)\n #next_time = index\n #break\n\n return 0 if next_time is None else next_time","def greedy_selector(self):\n r_k = 0 \n best_route = []\n cities_to_visit = [i for i in range(1, self.city_count)]\n for _ in range(1, self.city_count):\n s_ind = np.argmax([self.tau[(r_k, u)] for u in cities_to_visit])\n s_k = cities_to_visit.pop(s_ind)\n best_route.append((r_k, s_k))\n r_k = s_k\n best_route.append((r_k, 0))\n \n shortest_path = np.sum([self.phi[(p)] for p in best_route])\n return best_route, shortest_path","def calculate_random_move(self, vehicleamount, visit):\n self.depth += 1\n\n while True:\n number = (randint(0, 1))\n vehicle_id = (randint(0, vehicleamount-1))\n vehicle = self.vehicles[vehicle_id]\n state = self.get_board()\n if vehicle.orientation == 0: #horizontal\n if number == 0:\n if vehicle.x > 0: #left\n if state[vehicle.y][vehicle.x-1] == \"..\":\n self.vehicles[vehicle_id].x -=1\n if self.get_board().tostring() in visit:\n self.vehicles[vehicle_id].x += 1\n else:\n return self\n else:\n if vehicle.x + vehicle.length <= (len(state)-1): #right\n if state[vehicle.y][vehicle.x+vehicle.length] == \"..\":\n self.vehicles[vehicle_id].x += 1\n if self.get_board().tostring() in visit:\n self.vehicles[vehicle_id].x -= 1\n else:\n return self\n else: #vertical\n if number == 0:\n if vehicle.y - 1 >= 0: #up\n if state[vehicle.y-1][vehicle.x] == \"..\":\n self.vehicles[vehicle_id].y -= 1\n if self.get_board().tostring() in visit:\n self.vehicles[vehicle_id].y += 1\n else:\n return self\n else:\n if vehicle.y + vehicle.length <= (len(state)-1):\n if state[vehicle.y + vehicle.length][vehicle.x] == \"..\":#down\n self.vehicles[vehicle_id].y += 1\n if self.get_board().tostring() in visit:\n self.vehicles[vehicle_id].y -= 1\n else:\n return self","def next_node(self):\r\n to_visit = list(self.to_visit())\r\n if not to_visit:\r\n return None\r\n next_up = min(to_visit, key=lambda n: self.table[n][\"dist\"])\r\n connected = self.table[next_up][\"dist\"] != float(\"inf\")\r\n return next_up if connected else None","def neirest_neighbour(business, cells):\n array = cells.get_neighbours(business, num=1)\n neighbours = pd.DataFrame(array).set_index('index')\n index = neighbours['distance'].idxmin()\n return neighbours.loc[index]","def getNext(self, carPos):\n if carPos.lane != self:\n print \"car is on other lane\"\n return []\n next = []\n shortestDist = sys.maxint\n for car in self.carsPosition.itervalues():\n if car.isGoalFlag:\n next.append(car)\n continue\n if car.position is None:\n print \"the car has no position\"\n continue\n if car.car.id == carPos.car.id:\n continue\n distance = car.position - carPos.position\n if not car.free and (0 < distance < shortestDist): # only pick the cars in front of current car\n shortestDist = distance\n next.append(car)\n return next","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 exhaustive_search(city_list,until):\n all_tours = recursive_travel(city_list[0:until])\n shortest = shortest_tour(all_tours)\n return shortest","def nearest_neigbor(self, pc):\n coord = get_coordinates(pc)\n # deliveries\n pdist_deliv = {haversine(coord[0], coord[1], pcoord[1][0], pcoord[1][1]):pc for pc, pcoord in self.state.D_k.items()}\n pdist_list_deliv = list(pdist_deliv.keys())\n if len(pdist_list_deliv) > 0:\n val_deliv_min = min(pdist_list_deliv)\n else:\n val_deliv_min = 1e6 # great value to be discarded when comparing with val_pickup_min\n # pickups\n pdist_pickup = {haversine(coord[0], coord[1], pcoord[-1][0], pcoord[-1][1]):pc for pc, pcoord in self.state.P_k.items()}\n pdist_list_pickup = list(pdist_pickup.keys())\n\n if len(pdist_list_pickup) > 0:\n val_pickup_min = min(pdist_list_pickup)\n else:\n val_pickup_min = 1e6 # great value to be discarded when comparing with val_pickup_min\n\n if val_deliv_min == val_pickup_min and val_deliv_min == 1e6:\n print(\"All jobs completed: go to wait or stop if it's 12pm\")\n return 0\n\n if val_deliv_min < val_pickup_min:\n return pdist_deliv[val_deliv_min]\n\n elif val_deliv_min >= val_pickup_min:\n return pdist_pickup[val_pickup_min]\n else:\n raise valueError('Impossible comparison between val_deliv_min and val_pickup_min ')","def get_cheapest_neighbor(client, facilities):\n adj_facilities = client.get_facility_list(facilities)\n return min(adj_facilities, key=lambda fac: fac['cost'])","def choose_next(garden, pos):\n\n north = garden[pos[0] - 1][pos[1]] if pos[0] != 0 else -1\n south = garden[pos[0] + 1][pos[1]] if pos[0] != len(garden)-1 else -1\n east = garden[pos[0]][pos[1]+1] if pos[1] != len(garden[pos[0]])-1 else -1\n west = garden[pos[0]][pos[1]-1] if pos[1] != 0 else -1\n\n # I'm sure there is a shorter way for these as well\n max_val = max(north, south, east, west)\n next_pos = None\n if max_val == 0: # No more adjacent carrots\n next_pos == None\n elif max_val == north:\n next_pos = (pos[0] - 1, pos[1])\n elif max_val == south:\n next_pos = (pos[0] + 1, pos[1])\n elif max_val == east:\n next_pos = (pos[0], pos[1] + 1)\n elif max_val == west:\n next_pos = (pos[0], pos[1] - 1)\n\n return next_pos","def doRide(car, ride):\n global MAX_DISTANCE_START, MAX_DISTANCE_FINISH\n (a, b, x, y, s, f) = ride\n lenght_ride = abs(x - a) + abs(y - b)\n # Simple heuristic to make it faster\n if lenght_ride > MAX_DISTANCE_FINISH: # So it doesn't take too long rides\n return None\n if car is None or len(car) == 0: # No car or no rides asigned to the car\n (cx, cy) = INITIAL_POS\n cs = INITIAL_TIME\n else: # Else, look in the list\n last_ride = car[-1]\n (cx, cy) = tuple(rides[last_ride][0:2]) # Position of the car\n # When will the car be at that position\n cs = rides_done[last_ride][2]\n # Distance to the ride's starting intersection\n distance = abs(cx - a) + abs(cy - b)\n if distance > MAX_DISTANCE_START: # Do not take too far away ones\n return None\n when = max(cs + distance, s)\n if when + lenght_ride > f: # The car cant make it\n return None\n\n return when, when + lenght_ride, when == s","def get_next_unvisited(visited, shortest_paths):\n min_dist = math.inf\n min_node = None\n for node_id in shortest_paths:\n dist = shortest_paths[node_id][0]\n if dist < min_dist and visited[node_id] == False:\n min_dist = dist\n min_node = node_id\n return min_node","def kPaths(veh, currentEdge):\n # A set of all of the edges, used to reset the vehicle's internal estimated edge store\n edgesSet = set()\n k = 1\n # This is a fail safe in case there are less paths than K_MAX available for the vehicle to take\n timeOut = 0\n\n # Finding the best possible route for the vehicle\n traci.vehicle.rerouteTraveltime(veh, currentTravelTimes=False)\n\n # The vehicle's current route\n bestRoute = traci.vehicle.getRoute(veh)\n # Element of the current edge within the currentRoute\n currentEdgeIndex = bestRoute.index(currentEdge)\n # Altered route with the first element of the route being the current edge\n currentRoute = bestRoute[currentEdgeIndex:]\n edgesSet.update(currentRoute)\n\n # Recording down the current best route and time\n bestTime = sim.getGlobalRoutePathTime(currentRoute)\n routes = {}\n routes['{}_best'.format(k)] = (bestTime, currentRoute,)\n\n # This records the estimated travel time for each road segment in which the vehicle may take (with or without\n # penalisation applied) -- this is done on and reset on a vehicle-per-vehicle basis\n adjustedEdgeVehicle = {}\n for edge in currentRoute:\n adjustedEdgeVehicle[edge] = edgeSpeedGlobal[edge]\n\n # Creating up to k-1 additional routes\n while k < K_MAX:\n penalisePathTimeVehicle(veh, currentRoute, adjustedEdgeVehicle)\n\n traci.vehicle.rerouteTraveltime(veh, currentTravelTimes=False)\n newRoute = traci.vehicle.getRoute(veh)\n currentRoute = newRoute[currentEdgeIndex:]\n newRouteTime = sim.getGlobalRoutePathTime(currentRoute)\n\n # These are the routes which have already been selected\n currentEligibleRoutes = [x[1] for x in routes.values()]\n # Ensuring the route doesn't exist within the existing eligible routes, the route contains the edge in which the\n # vehicle is currently occupying, and the route is not currently the best route\n if currentRoute not in currentEligibleRoutes and currentEdge in currentRoute:\n timeOut = 0\n # This keeps track if the calculated 'best' route time is above that of the calculated new route time\n bestRouteMoreThanNewRouteTime = False\n\n \"\"\"\n Sometimes the roads suffer so much congestion that there are issues with reliable estimation of travel\n times given by TraCI. TraCI may sometimes give overblown estimations of the travel times of an edge, for\n example if the edge is being blocked and no movement is being made, the estimated time may be \n disproportionally large compared to it's real-world equivalent predicted time taken; this problem persists\n even with a rerouting device being connected to the vehicles which allows for more accurate 'smoothed' \n aggregated travel times- this is a fault inherent to TraCI. \n \n In an attempt to alleviate this, the estimated travel times are bounded to 15x their free-flow speed. \n However, this sometimes causes the best time to no longer be the best time depending on the number of \n edge travel time boundings in a route (which could alter the predicted time for a route given we are \n now estimating some of the edge times). \n \n Given this, we instead work out the ratio between the best travel time and the currentRoute travel time, \n we multiply this ratio against the best travel time to give a better, more accurate estimation of the \n currentRoute's travel time.\n \"\"\"\n if newRouteTime < bestTime:\n # These are the predicted route times which are given directly from TraCI\n bestTimeGivenByTraci = 0\n newRouteTimeGivenByTraci = 0\n\n # These are the smoothed travel times which are generated through the vehicle's individual rerouting\n # device\n smoothedBestTime = 0\n smoothedNewTime = 0\n\n # Times for the best route\n for edge in routes['1_best'][1]:\n bestTimeGivenByTraci += traci.edge.getTraveltime(edge)\n smoothedBestTime += float(traci.vehicle.getParameter(veh, \"device.rerouting.edge:{}\".format(edge)))\n\n # Times for the new route\n for edge in currentRoute:\n newRouteTimeGivenByTraci += traci.edge.getTraveltime(edge)\n smoothedNewTime += float(traci.vehicle.getParameter(veh, \"device.rerouting.edge:{}\".format(edge)))\n\n traciRatio = newRouteTimeGivenByTraci / bestTimeGivenByTraci\n smoothedRatio = smoothedNewTime / smoothedBestTime\n\n \"\"\"\n In extremely rare cases, TraCI can erroneously return an incorrect edge travel time which means\n that the 'best' travel time may not actually be the best when taking these estimated travel time\n measurements; this can result in ratios < 1.\n \"\"\"\n if traciRatio < 1 and smoothedRatio < 1:\n bestRouteMoreThanNewRouteTime = True\n\n # Add the new time to the list so that it can be determined whether or not the existing times can\n # exist given this new best time (with boundaries in mind)\n routes['{}_best'.format(k + 1)] = (newRouteTime, currentRoute,)\n\n # All of the route and time pair combinations\n tupleList = []\n for key in routes:\n timeRouteTuple = routes[key]\n tupleList.append(timeRouteTuple)\n\n # Sort the tuples with the lowest time being at index 0, with the longest being at index k-1\n sortedTuples = sorted(tupleList, key=lambda x: x[0])\n\n # Placing the contents of the sortedTuple into routes\n counter = 0\n for key in routes:\n routes[key] = sortedTuples[counter]\n counter += 1\n\n # Best time will now be in the first position\n bestTime = routes['1_best'][0]\n\n # Delete any routes which don't conform to <= new best time *\n for key in deepcopy(routes):\n if routes[key][0] >= bestTime * KPATH_MAX_ALLOWED_TIME:\n del routes[key]\n\n # Resetting k depending on how many elements are left after removal\n k = len(routes)\n else:\n # This takes the most accurate ratio (which is deemed to be the ratio which is closest to 1)\n traciRatio = min([traciRatio, smoothedRatio], key=lambda v: abs(v - 1))\n # Work out the new, more accurate currentRoute travel time based on this ratio\n newRouteTime = bestTime * traciRatio\n\n # New route's estimated time doesn't exceed bestTime*KPATH_MAX_ALLOWED_TIME of the optimal route time\n if newRouteTime <= bestTime*KPATH_MAX_ALLOWED_TIME and not bestRouteMoreThanNewRouteTime:\n k += 1\n for edge in currentRoute:\n if edge not in adjustedEdgeVehicle:\n adjustedEdgeVehicle[edge] = edgeSpeedGlobal[edge]\n edgesSet.update(currentRoute)\n routes['{}_best'.format(k)] = (newRouteTime, currentRoute,)\n else:\n break\n else:\n timeOut += 1\n # Time out limit exceeded\n if timeOut == KPATH_TIMEOUT:\n break\n\n # Selecting a random route\n ranNum = random.randint(1, len(routes))\n\n routeChoice = routes['{}_best'.format(ranNum)]\n\n # Setting the additional (estimated) extra time in which the vehicle has taken due to reroutings\n routeChoiceTimeTaken = routeChoice[0]\n bestChoiceTimeTaken = routes['1_best'][0]\n extraTime = routeChoiceTimeTaken - bestChoiceTimeTaken\n cumulativeExtraTime[veh] += abs(extraTime)\n\n traci.vehicle.setRoute(veh, routeChoice[1])\n\n resetVehicleAdaptedTravelTime(veh, edgesSet)\n\n # These are the routes which were available to be selected\n routeList = [x[1] for x in routes.values()]\n\n return routeList","def find_best_cycle(road_map):\n #Assume the best_cycle is the initial road map and calculate total distance \n best_cycle = road_map\n best_cycle_dist = compute_total_distance(road_map)\n best_attempts = [best_cycle_dist]\n # For each city in the road map\n for i in range(len(road_map)):\n for swaps in range(10000):\n #A random number between 0 and total number of cities is generated.\n number = int(len(road_map) * random.random())\n # Create a test tuple where the first field in the tuple is the road map,\n # with two cities swapped, and second field is total distance.\n # The type of swap depends on whether the random number is odd or even.\n # If even or if i is equal to number, the cities at index i and i+1 is swapped.\n # If odd and i is not equal to number, the cities at index i and number are swapped.\n # As a result, on each swap, there is\n # 50% chance of either type of swap being selected.\n if number % 2 == 1 and i != number:\n test = swap_cities(best_cycle,i,number)\n else:\n test = swap_adjacent_cities(best_cycle,i)\n # Compare the second field with current best cycle distance\n # If current best cycle distance is greater, then set best cycle\n # to the road map after swapping \n if best_cycle_dist > test[1]:\n best_cycle = test[0]\n best_cycle_dist = test[1]\n if best_attempts[len(best_attempts)-1] > best_cycle_dist:\n best_attempts.append(best_cycle_dist)\n return best_cycle, best_cycle_dist, best_attempts","def calculate_next_move(self, visit):\n self.depth += 1\n new_boards = []\n for vehicle_id in range(len(self.vehicles)):\n vehicle = self.vehicles[vehicle_id]\n state = self.get_board()\n if vehicle.orientation == 0: #horizontal\n if vehicle.x > 0: #left\n if state[vehicle.y][vehicle.x-1] == \"..\":\n self.vehicles[vehicle_id].x -=1\n if not self.get_board().tostring() in visit:\n if not self.get_board().all in new_boards:\n new_board = deepcopy(self)\n self.vehicles[vehicle_id].x += 1\n new_board.parent = self\n new_boards.append(new_board)\n else:\n self.vehicles[vehicle_id].x += 1\n\n if vehicle.x + vehicle.length <= (len(state)-1): #right\n if state[vehicle.y][vehicle.x+vehicle.length] == \"..\":\n self.vehicles[vehicle_id].x += 1\n if not self.get_board().tostring() in visit:\n if not self.get_board().all in new_boards:\n new_board = deepcopy(self)\n self.vehicles[vehicle_id].x -= 1\n new_board.parent = self\n new_boards.append(new_board)\n else:\n self.vehicles[vehicle_id].x -= 1\n\n else: #vertical\n if vehicle.y - 1 >= 0: #up\n if state[vehicle.y-1][vehicle.x] == \"..\":\n self.vehicles[vehicle_id].y -= 1\n if not self.get_board().tostring() in visit:\n if not self.get_board().all in new_boards:\n new_board = deepcopy(self)\n self.vehicles[vehicle_id].y += 1\n new_board.parent = self\n new_boards.append(new_board)\n else:\n self.vehicles[vehicle_id].y += 1\n\n if vehicle.y + vehicle.length <= (len(state)-1):\n if state[vehicle.y + vehicle.length][vehicle.x] == \"..\":#down\n self.vehicles[vehicle_id].y += 1\n if not self.get_board().tostring() in visit:\n if not self.get_board().all in new_boards:\n new_board = deepcopy(self)\n self.vehicles[vehicle_id].y -= 1\n new_board.parent = self\n new_boards.append(new_board)\n else:\n self.vehicles[vehicle_id].y -= 1\n self.depth -= 1\n return new_boards","def _get_vehicle(self, vehicle):\n vehicle_bp = self.blueprint_lib.find(vehicle)\n spawn_point = random.choice(self.world.get_map().get_spawn_points())\n self.last_location = spawn_point.location\n vehicle = None\n for _ in range(10):\n vehicle = self.world.try_spawn_actor(vehicle_bp, spawn_point) # this will return None if spawning failed\n if vehicle:\n break\n if not vehicle:\n raise(\"Spawning failed, perhaps there are too many actors already in world\")\n \n return vehicle","def next_step(self, goal, traps=False): #TODO: test (maybe change to l1 dist?)\n kyu = PriorityQueue()\n kyu.put((0, self.player))\n came_from = {self.player: None}\n costs_agg = {self.player: 0}\n\n while not kyu.empty():\n curr = kyu.get()[1]\n if curr == goal: break\n\n for next in self.valid_neighbors(curr):\n new_cost = costs_agg[curr] + (5 if traps and self.traps[next] else 1)\n if next not in costs_agg.keys() or new_cost < costs_agg[next]:\n costs_agg[next] = new_cost\n kyu.put((new_cost + l2(next, goal), next))\n came_from[next] = curr\n \n if goal in came_from.keys():\n return came_from[goal]\n else:\n raise RuntimeWarning(\"no path between monster and player\")\n return goal","def getNextNodeUsingCellDiff(kGoalState):\n \n global fringe\n global solutions\n\n \n\n\n\n minNode = None\n minCost = 99999999999\n minNodeIndex = -1\n\n \n pnode = None\n pcost = None\n\n if len(solutions)>0 and solutions[0] != None:\n pnode = solutions[0];\n pcost = getHValueForNode(pnode,kGoalState)\n #print pnode, pcost\n # raw_input()\n \n\n\n\n for idx,node in enumerate(fringe):\n #get the heu. function values\n g_value = getHValueForNode(node,kGoalState)\n \n\n if g_value < minCost:\n minNode = node\n minNodeIndex = idx\n minCost = g_value\n\n\n fringe.pop(minNodeIndex)\n c = getHValueForNode(minNode,kGoalState)\n if pnode != None:\n if c > pcost:\n minNode = None\n \n return minNode","def get_dists_to_from_new_cust(\n customer: Customer,\n known_customers: List[Customer],\n osr_api_key: str,\n) -> Dict[Tuple[str, str], float]:\n\n # If there are no existing customers, just return a 0-distance dict for the\n # single self-directed arc.\n if not known_customers:\n return {(customer.cust_id, customer.cust_id): 0.0}\n\n # Instantiate our client to pull the distance matrix.\n osr_client = client.Client(key=osr_api_key)\n\n # Get the list of customer coordinates, along with their IDs.\n # Note that they're in (lon, lat) order instead of (lat, lon).\n cust_coords_w_id = [(known_cust.cust_id, (known_cust.lon, known_cust.lat)) for known_cust in known_customers]\n\n # Append the new customer.\n cust_coords_w_id.append((customer.cust_id, (customer.lon, customer.lat)))\n\n # Note the number of total customers, along with the index of the new customer that we need distances for.\n n = len(cust_coords_w_id)\n new_cust_idx = n-1\n\n # Define the basic request we'll make to fetch the distance matrix.\n request = {\n 'locations': [cust_coords[1] for cust_coords in cust_coords_w_id],\n 'profile': 'driving-car',\n 'metrics': ['duration'],\n }\n\n # First, get the distances FROM the new customer to all the existing customers\n request['sources'] = [new_cust_idx]\n response = osr_client.distance_matrix(**request)['durations']\n logging.info(\"Distances *FROM* new customer retrieved\")\n new_distances = {\n (cust_coords_w_id[new_cust_idx][0], cust_coords_w_id[i][0]): response[0][i]\n for i in range(n) # This also includes the distance from the new customer to itself\n }\n\n # Next, get the distances TO the new customer from all the existing customers\n request.pop('sources') # no longer want to specify a single source\n request['destinations'] = [new_cust_idx] # but we do want to specify a destination\n response = osr_client.distance_matrix(**request)['durations']\n logging.info(\"Distances *TO* new customer retrieved\")\n new_distances.update({\n (cust_coords_w_id[i][0], cust_coords_w_id[new_cust_idx][0]): response[i][0]\n for i in range(new_cust_idx) # don't include the dist to itself this time\n })\n \n return new_distances","def get_next_index(car_position):\n next_index = False\n\n index_car_position = car_position[2]\n next_index_car_position = index_car_position + 1\n next_car_position = self.waypoints_list[\n next_index_car_position]\n\n if next_car_position[1] == car_position[1]:\n if car_position[1] < vehicle_posy < next_car_position[1]:\n next_index = True\n # rospy.logerr(\"check_point1\")\n\n elif next_car_position[0] == car_position[0]:\n if car_position[0] < vehicle_posx < next_car_position[0]:\n next_index = True\n # rospy.logerr(\"check_point2\")\n\n else:\n coeff1 = ((next_car_position[1] - car_position[1]) /\n (next_car_position[0] - car_position[0]))\n\n coeff2 = -(1 / coeff1)\n\n b_low = car_position[1] - (coeff2 * car_position[0])\n b_high = next_car_position[1] - (coeff2 * next_car_position[0])\n\n x_b_p = (self.pose_position.y - b_low) / coeff2\n y_b_p = (coeff2 * self.pose_position.x) + b_low\n\n x_b_np = (self.pose_position.y - b_high) / coeff2\n y_b_np = (coeff2 * self.pose_position.x) + b_high\n\n if x_b_p < vehicle_posx < x_b_np and \\\n y_b_p < vehicle_posy < y_b_np:\n next_index = True\n\n if next_index:\n index_car_position = car_position[2] + 1\n next_index_car_position = index_car_position + 1\n next_car_position = self.waypoints_list[\n next_index_car_position]\n\n return index_car_position","def getNextNodeUsingTotalStepsToTravel(kGoalState):\n \n global fringe\n global solutions\n\n\n\n minNode = None\n minCost = 99999999999\n minNodeIndex = -1\n\n \n pnode = None\n pcost = None\n\n if len(solutions)>0 and solutions[0] != None:\n pnode = solutions[0];\n pcost = getTotalStepsToReachGoalState(pnode,kGoalState)\n # print pnode, pcost\n # raw_input()\n \n\n\n\n for idx,node in enumerate(fringe):\n #get the heu. function values\n g_value =getTotalStepsToReachGoalState(node,kGoalState)\n \n\n if g_value < minCost:\n minNode = node\n minNodeIndex = idx\n minCost = g_value\n\n\n fringe.pop(minNodeIndex)\n c = getTotalStepsToReachGoalState(minNode,kGoalState)\n if pnode != None:\n if c > pcost:\n minNode = None\n \n return minNode","def get_quickest_route_via(network, start,destination, vias):\n # On récupère la liste des villes\n list_city = network[1].keys()\n \n # On vérifie que toutes les villes existent\n for via in vias:\n if via not in list_city:\n\t return None\n\t \n # On utilise Floyd pour parcourir les chemins les plus rapide de ville ne ville\n roads = []\n done = []\n city_previous = start\n for via in vias:\n\troad = get_shortest_route_floyd(network, city_previous, via) #done[:-1]) # dépend si on peut ou pas repasser par les villes déjà visité\n\tif road != None:\n\t roads.extend( road )\n\t done.append( via )\n\t city_previous = via\n\t \n # On utilise Floyd pour finir le parcourt jusqu'à la ville de fin\n road = get_shortest_route_floyd(network, city_previous,destination) #done[:-1]) # dépend si on peut ou pas repasser par les villes déjà visité\n if road != None:\n roads.extend( road )\n\t\n # Si on trouve rien, on renvoie None\n if roads == []:\n return None\n return roads","def choose_destination(self, graph, current, unvisited):\n if len(unvisited) == 1:\n return unvisited[0]\n scores = self.get_scores(graph, current, unvisited)\n return self.choose_node(unvisited, scores)","def find_best_cycle(road_map):\n \n best_cycle = road_map\n best_dist = compute_total_distance(best_cycle)\n i = 0\n \n try: \n while i < 10000:\n attempt_map = shift_cities(best_cycle)\n rand_idx1 = random.randint(0, len(best_cycle)-1)\n rand_idx2 = random.randint(0, len(best_cycle)-1)\n (new_map, distance) = swap_cities(attempt_map, rand_idx1, rand_idx2)\n if distance < best_dist:\n best_dist = distance\n best_cycle = new_map\n i += 1\n except Exception as e:\n print('Error with find_best_cycle function: '+str(e))\n \n return best_cycle","def getNextDest(self):\n\n if self.direction_forward:\n if len(self.destinations)-1 == self.current_loc: #if Autobuz reaches rightmost destination, it also takes a break and changes directions\n self.direction_forward = False #Autobuz changes direction\n self.updateOmLocation()\n return self.destinations[self.current_loc], (self.break_duration + self.trip_duration) #return destination reached and elapsed time\n \n else:\n self.current_loc += 1\n self.updateOmLocation()\n return self.destinations[self.current_loc], self.trip_duration\n \n else:\n if 0 == self.current_loc: #if Autobuz reaches leftmost destination, it also takes a break and changes directions\n self.direction_forward = True #Autobuz changes direction\n self.updateOmLocation()\n return self.destinations[self.current_loc], (self.break_duration + self.trip_duration)\n \n else:\n self.current_loc -= 1\n self.updateOmLocation()\n return self.destinations[self.current_loc], self.trip_duration","def knearest_amongst_user_rated( self, restaurant_id, user_id, k = 7, reg = 3.0 ):\n\t\tuser_rated = self.df[ self.df['user_id'] == user_id ]['business_id'].unique()\n\t\treturn self.knearest( restaurant_id = restaurant_id, \n\t\t\t\t\t\t\t set_of_restaurants = user_rated, k = k, reg = reg )","def local_optimum(self, tour: Tour):\n better = tour\n cnt = 0\n while better is not None:\n # if cnt % 20 == 0:\n print(\"---------------------------------------------\\n The \", cnt, \"time.\")\n print(\"Improved tour:\", list(better.iter_vertices()))\n print(\"Improved cost:\", self.tour_cost(better))\n cnt += 1\n tour = better\n better = self.improve(tour)\n return tour","def get_next(self,day,link,current_time,route): \n if day not in self.data:\n print('missing day')\n return None\n if link not in self.data[day]:\n print([l for l in self.data[day]])\n print('missing link')\n return None\n if route not in self.data[day][link]:\n print('missing route')\n return None\n import numpy as np\n try:\n #efficent numpy look up.\n index=[np.searchsorted(self.data[day][link][route][0:,0],current_time)]\n except:\n print('broken for this route')\n return None\n if index[0] < len(self.data[day][link][route]):\n return self.data[day][link][route][index[0]]\n else:\n return None","def FindNext():\r\n return _hiew.HiewGate_FindNext()","def find_next(graph, strategy, mission, node, parent_node=None,\n matrix=None):\n debug('strategy =', strategy)\n node_gt = graph.name2node[node]\n nodes_gt = [n for n in node_gt.out_neighbours()]\n nodes = [graph.vp['name'][n] for n in nodes_gt]\n debug('nodes =', nodes)\n if strategy == 'random':\n if parent_node is not None and parent_node not in nodes:\n nodes.append(parent_node)\n return random.choice(nodes)\n neighbor_targets = [n for n in nodes if n in mission.targets[0]]\n if neighbor_targets:\n debug('target in neighbors')\n return neighbor_targets[0]\n\n nodes = [n for n in nodes if n not in mission.visited]\n try:\n candidates = {n: matrix[n, mission.targets[0][0]] for n in nodes}\n except KeyError:\n pdb.set_trace()\n except TypeError, e:\n print(e)\n pdb.set_trace()\n if not candidates:\n chosen_node = None # abort search\n else:\n if strategy == 'title_stochastic' and random.random() <= 0.05:\n chosen_node = random.choice(candidates.keys())\n debug('randomly selecting node', chosen_node)\n return chosen_node\n chosen_node = max(candidates.iteritems(),\n key=operator.itemgetter(1))[0]\n debug('candidates are:')\n for k, v in candidates.items():\n debug(k, ':', v)\n if chosen_node == parent_node:\n debug('backtracking to node', parent_node)\n return None\n debug('going to ', chosen_node)\n return chosen_node","def opt_road(player, board, building_vertex):\n player_buildings = board.get_player_settlements(player.player_id) + board.get_player_cities(player.player_id)\n player_roads = board.get_player_roads(player.player_id)\n accessible_vertices = sorted(set(player_buildings+ [v for pair in player_roads for v in pair]), \\\n key = lambda v: manhattan_distance(v,building_vertex,board))\n if building_vertex in accessible_vertices:\n print(\"Error: Building vertex already accessible, do not need road.\")\n return None, None\n for v in accessible_vertices:\n neighbor_vertices = []\n x,y = board.get_vertex_location(v)\n for dx, dy in [[0,1],[0,-1],[1,0],[-1,0]]:\n xx = x + dx\n yy = y + dy\n if board.get_vertex_number(xx,yy) in range(board.max_vertex+1):\n neighbor_vertices.append(board.get_vertex_number(xx,yy))\n neighbor_vertices = sorted(neighbor_vertices, key = lambda v: manhattan_distance(v,building_vertex,board))\n for n in neighbor_vertices:\n if board.if_can_build_road(v, n, player.player_id):\n v_t = list(board.get_vertex_location(v))\n n_t = list(board.get_vertex_location(n))\n return v_t, n_t\n print(\"need to implement default behavior\")\n return None,None","def nearest(node):\n count = 0\n distance = 100000\n while count != node_count[0]:\n city = d_list[node.value - 1]\n if city != []:\n if city[0][1] < distance:\n distance = city[0][1]\n new_city = city[0][0]\n closest_city = node.value\n node = node.left\n count = count + 1\n return (closest_city, new_city, distance)","def greedy_path():\n itinerary = []\n cities = all_cities(data_set)\n starting_city = randomize_city_start(cities.keys()) # start from a random city\n # print \"starting_city: %s\" % starting_city\n cities_visited = {}\n \n # iterate through all cities\n count = 1\n while True:\n possible_routes = []\n #distance = []\n # print \"starting_city: %s\" % starting_city\n for path in data_set:\n # we only start with city that we have assigned in starting_city\n if starting_city in path['city_start']:\n # we don't go to cities we have visited\n if path['city_end'] in cities_visited:\n continue\n else:\n # print \"path: \", path\n possible_routes.append(path) # add the city if not in the list\n \n if not possible_routes:\n break\n # append this to itinerary\n route = get_shortest_route(possible_routes)\n count += 1\n itinerary.append(route)\n # add this city to visited_cities list\n cities_visited[route[0]] = count\n starting_city = route[1]\n \n return itinerary","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 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 acceptance(current, candidate,fitness):\n cost_current = fitness(current)\n cost_candidate = fitness(candidate)\n if cost_current < cost_candidate: # Minimization\n return current\n else:\n return candidate","def road_next(self, vehicle, on_arrive, time):\n events = []\n edge = vehicle.current\n if edge is not None:\n # leave previous edge\n edge['occupancy'] -= self.roads.vehicle_size\n if edge['occupancy'] < 0:\n raise Exception('occupancy should be positive')\n vehicle.route.pop(0)\n self.data['road_capacities'][edge['id']].append((float(edge['occupancy']), float(time)))\n\n # compute next leg\n leg = self.road_travel(vehicle.route, vehicle.type)\n\n # random accidents\n if random.random() < config.BASE_ACCIDENT_PROB:\n # sort edges by occupancy\n edges = [(e[:3], e[-1]['occupancy'])\n for e in self.roads.network.edges(keys=True, data=True)\n if e[-1]['occupancy'] > 0]\n if len(edges) > 0:\n edges, probs = zip(*edges)\n edge_idxs = range(len(edges))\n probs = probs/np.sum(probs)\n edge_idx = np.random.choice(edge_idxs, 1, p=probs)[0]\n edge = edges[edge_idx]\n self.roads.network.edges[edge]['accident'] = True\n logger.debug('Accident occurred at edge: {}'.format(edge))\n\n # Accident cleared up event\n clear_time = random.randint(*config.ACCIDENT_CLEAR_TIME)\n events.append((time+clear_time, partial(self.clear_accident, edge)))\n\n # arrived\n if leg is None:\n return events + on_arrive(time)\n\n # TODO replanning can occur here too,\n # e.g. if travel_time exceeds expected travel time\n leg, edge, travel_time = leg\n\n # enter edge\n edge['occupancy'] += self.roads.vehicle_size\n if edge['occupancy'] <= 0:\n raise Exception('adding occupant shouldnt make it 0')\n self.data['road_capacities'][edge['id']].append((float(edge['occupancy']), float(time)))\n\n vehicle.current = edge\n\n # cast to avoid errors with serializing numpy types\n if self.save_history and time >= self.history_window[0] and time <= self.history_window[1]:\n self.history[vehicle.id].append((float(time), float(travel_time), leg))\n\n # return next event\n # TODO this assumes agents don't stop at\n # lights/intersections, so should add in some time,\n # but how much?\n # or will it not affect the model much?\n return events + [(travel_time, partial(self.road_next, vehicle, on_arrive))]","def goto(vehicle, dNorth, dEast):\n goto_function = vehicle.simple_goto # can be changed\n currentLocation = vehicle.location.global_relative_frame\n targetLocation = get_location_metres(currentLocation, dNorth, dEast)\n targetDistance = get_distance_metres(currentLocation, targetLocation)\n goto_function(targetLocation)\n\n #Stop action if we are no longer in guided mode.\n while vehicle.mode.name == \"GUIDED\": \n remainingDistance = get_distance_metres(vehicle.location.global_relative_frame, targetLocation)\n #print \"Distance to target: \", remainingDistance\n if remainingDistance <= shared.WP_RADIUS: #Just below target, in case of undershoot.\n #print \"Reached target\"\n break;\n\n time.sleep(0.5)","def heuristic(current, goal):\r\n distance = getDistance(current, goal)\r\n return distance","def cust_loc(sol, cust):\r\n cust_ind = [] # [route_loc, cust_loc]\r\n for i, rt in enumerate(sol):\r\n if cust in rt:\r\n cust_ind.append(i)\r\n cust_ind.append(rt.index(cust))\r\n return cust_ind\r\n\r\n print('Costomer not in the solution: ', cust)","def get_next_node(node_destinatari,node_enviant):\n if node_list.index(node_destinatari)>node_list.index(node_enviant):\n #sentit=\"up\"\n node_anterior=node_list[node_list.index(id)-1]\n node_seguent=node_list[node_list.index(id)-2]\n if node_list.index(id)-3 < len(node_list):\n node_seguent2=node_list[node_list.index(id)-3]\n else:\n node_seguent2=node_seguent\n else:\n return(id,id,id)\n print(\"Get_next_node \",node_destinatari,node_enviant,\" result \",node_anterior,node_seguent,node_seguent2)\n return(node_anterior,node_seguent,node_seguent2)","def getNearestPassenger(driver, passengers):\n driver = driver.reshape((1, 2))\n assert (driver.shape == (1, 2))\n assert (passengers.shape[1] == 5)\n\n mask = passengers[:, -1] == 1\n tmp = passengers[mask]\n\n dis = np.linalg.norm(tmp[:, 0:2].copy() - driver)\n mini = np.argmin(dis)\n tmp[mini, -1] = 0\n passengers[mask] = tmp\n return tmp[mini, 0:4], passengers, tmp.shape[0] - 1","def _compute_connection(current_waypoint, next_waypoint, threshold=35):\n n = next_waypoint.transform.rotation.yaw\n n = n % 360.0\n\n c = current_waypoint.transform.rotation.yaw\n c = c % 360.0\n\n diff_angle = (n - c) % 180.0\n if diff_angle < threshold or diff_angle > (180 - threshold):\n return RoadOption.STRAIGHT\n elif diff_angle > 90.0:\n return RoadOption.LEFT\n else:\n return RoadOption.RIGHT","def get_distance(highway_now: list, car_index: int) -> int:\n\n distance = 0\n cells = highway_now[car_index + 1 :]\n for cell in range(len(cells)): # May need a better name for this\n if cells[cell] != -1: # If the cell is not empty then\n return distance # we have the distance we wanted\n distance += 1\n # Here if the car is near the end of the highway\n return distance + get_distance(highway_now, -1)","def dispersy_get_walk_candidate(self):\n now = time()\n result = None\n method = self._scenario_script.candidate_strategy\n #walk_type=\"with_restarts\"\n\n def get_score(candidate):\n try:\n peer = self._scenario_script.get_peer_from_candidate(candidate)\n except:\n logger.warning(\"fault in the database: unable to get peer from candidate\")\n return 0.0\n member = self._dispersy.get_member(peer.public_key)\n return self._scores.get(member.database_id, 0.0)\n \n def prob_choice(bias):\n randNum = pythonrandlib.random() # in [0,1)\n if sum(bias)>0:\n sum_mass = 0.0\n result = 0\n norm_bias=[ x*(1/sum(bias)) for x in bias]\n for mass in norm_bias:\n sum_mass += mass\n if randNum <= sum_mass:\n return result\n result+=1\n else:\n result = int(randNum*len(bias))\n return result\n # use the default Dispersy strategy if neither enable_probabilistic_candidate nor\n # enable_deterministic_candidate is chosen\n if method == \"dispersy\":\n result = self.dimitra_dispersy_get_walk_candidate()\n\n # introduction based on the locally compute scores\n\n if self._scenario_script.enable_following:\n #if walk_type=\"with_restarts\":\n logger.info(\"start of the RW-following\")\n \n # with teleportation probability 0.2\n if pythonrandlib.random() < 0.2:\n self.log(\"walk-teleport\")\n logger.info(\"teleportation phase with probability 0.2\")\n pass\n\n\n else: \n logger.info(\"RW on process: selection of the next node\")\n candidates = [(candidate.last_intro, candidate)\n for candidate\n in self._candidates.itervalues()]\n # if candidate.is_eligible_for_walk(now, method=method)]\n if candidates:\n candidates.sort()\n result = candidates[-1][1]\n # this must be enabled for churn\n # if not result.is_eligible_for_walk(now, method=\"dispersy\"):\n # result = None\n\n #logger.info(\"node %d chooses peer_number:%d\", self._scenario_script.peer_number, result.peer_number)\n #if walk_type=\"early_teminated\":\n # ttl<-0\n # # with teleportation probability 0.2\n # if ttl>7:\n # method = \"probabilistic\"\n\n # else:\n # candidates = [(candidate.last_intro, candidate) for candidate in self._candidates.itervalues() if candidate.is_eligible_for_walk(now)]\n # if candidates:\n # ttl<-ttl+1\n # candidates.sort()\n # yield candidates[-1]\n\n #if method in (\"probabilistic\", \"deterministic\"):\n\n #[(SCORE, CANDIDATE), (SCORE, CANDIDATE), ...]\n # candidates = [(get_score(candidate), candidate)\n # for candidate\n # in self._candidates.itervalues()\n # if candidate.is_eligible_for_walk(now, method=method)]\n # if candidates:\n #### Preobabilistic\n # assume sum of bias is 1\n\n # if method==\"probabilistic\":\n \n # candidate_index = prob_choice([score for score, candidate in candidates])\n # result = candidates[candidate_index][1]\n\n # if method==\"deterministic\":\n # yield candidates in best to worst order\n # sorted(candidates, reverse=True)\n # result = candidates[0][1]\n\n if result is None: \n logger.info(\"RW failed: back to the bootstrap nodes \")\n # FALLBACK TO BOOTSTRAP NODES\n #bootstrap_candidates = list(self._iter_bootstrap(once=True))\n #pythonrandlib.shuffle(bootstrap_candidates)\n #for candidate in bootstrap_candidates:\n # if candidate:\n # result = candidate\n # break\n try:\n list_member = [self._dispersy.get_member_from_database_id(member_id) for member_id, in self._database.execute(u\"SELECT member FROM book\")]\n list_peer = [self._scenario_script.get_peer_from_public_key(member.public_key) for member in list_member]\n except RuntimeError:\n return None\n \n candidates = [WalkCandidate(peer.lan_address, False, peer.lan_address, peer.wan_address, u\"unknown\")\n for peer\n in list_peer]\n candidates = [(get_score(candidate), candidate) for candidate in candidates] \n if candidates:\n candidate_index = prob_choice([score for score, candidate in candidates])\n result = candidates[candidate_index][1]\n #can=[self._scenario_script.get_peer_from_candidate(candidate).peer_number for candidate in candidates]\n #list_cand= intersect(ver,can)\n # list_peer.sort(key=lambda peer: peer.peer_number)\n #if list_peer:\n #index=randint(0,(len(list_cand)-1))\n #member = list_cand[index]\n \n # if self._scenario_script.peer_number in (0, 499):\n # peer = list_peer[0] \n # else:\n # peer = list_peer[-1]\n \n #candidate = candidates[index_in_can]\n #candidate=\n #peer_tuple=self._scenario_script.get_peer_from_public_key(member.public_key)\n # result = WalkCandidate(peer.lan_address, False, peer.lan_address,peer.wan_address,u\"unknown\")\n #self.log(\"available-candidates\", \n # verified=[str(candidate) for candidate in self.dispersy_yield_verified_candidates()], \n # unverified=[str(candidate) for candidate in self.dispersy_yield_candidates()])\n\n if result is None:\n self.log(\"walk-candidate\", strategy=method, lan_address=None, wan_address=None)\n logger.warning(\"no candidates or bootstrap candidates available\")\n\n else:\n self.log(\"walk-candidate\", strategy=method, lan_address=result.lan_address, wan_address=result.wan_address)\n\n return result","def findNextMove(curHVal):\n minHCalc = curHVal; #Initializing to curHVal\n minNewPosition = (0,0); #Initializing it\n\n tempBoardPositions = [x for x in positions]\n \n for move in findPlacesToMove():\n #Move number to blank\n tempBoardPositions[curBlank[0]][curBlank[1]] = tempBoardPositions[move[0]][move[1]];\n #Move blank to new move position\n tempBoardPositions[move[0]][move[1]] = 0;\n \n hVal = heuristicValueOfPosition(tempBoardPositions);\n if(hVal < minHCalc):\n minHCalc = hVal;\n minNewPosition = move;\n \n #Resetting board to what it was before this move\n tempBoardPositions[move[0]][move[1]] = tempBoardPositions[curBlank[0]][curBlank[1]]\n #tempBoardPositions[curBlank[0]][curBlank[1]] = 0;\n\n print(\"After calc -- {}\".format(positions))\n \n if minHCalc < curHVal:\n return (minNewPosition, minHCalc)\n else:\n return -1; #That we have reached local minima","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 pickBestCandidateToMergeWith(segmentToMerge,neighbours,mergedSegments,updatedSpeed,weights):\n criteronScores = [\n profileSim(segmentToMerge,neighbours,updatedSpeed),\n directtion(segmentToMerge,neighbours,mergedSegments),\n shareNoEdges(segmentToMerge,neighbours,mergedSegments)\n ]\n return neighbours[sum(criteronScores*weights).argmin()]","def shortest_flight(g):\n min_distance = sys.maxsize\n min_destination = None\n min_key = None\n \n for key in g.city_dict:\n for flight in g.city_dict[key].get_flights_out():\n if(flight[1] < min_distance):\n min_key = key\n min_destination = flight[0]\n min_distance = flight[1]\n return g.city_dict[min_key].get_name(), min_destination, min_distance","def heuristic(current, goal):\r\n\r\n return Vector2.fromCell(current).distanceTo(Vector2.fromCell(goal))","def related_movie_offset(movie_id, customer_id):\n offset = 0.0\n if movie_id in CACHE_RELATED_MOVIES:\n for other_mov, weight in CACHE_RELATED_MOVIES[movie_id].items():\n if customer_id in CACHE_ANSWERS[other_mov]:\n offset += weight * (netflix_predict(other_mov, customer_id) - CACHE_ANSWERS[other_mov][customer_id])\n return -1 * offset","def succ_car_other_lane(self):\n other_lane = self.other_lane()\n\n for i in range(self.road.N):\n if self.road.cells[other_lane][(self.x - (i + 1)) % (self.road.N-1)] != -1:\n return self.road.cars[self.road.cells[other_lane][(self.x - (i + 1)) % (self.road.N-1)]]","def plan(cur_pos: Node, goal_pos: Node, cur_heading: float, new_obst_segments: [ObstacleSegment]) \\\n -> (NavMode, [Node]):\n global d_reach, v_followed, v_diff, d_followed_rel, obst_id_to_follow, bf_waypoint\n # find updated obstacle with obst_id_to_follow\n obst_to_follow = find_obst(obst_id_to_follow, new_obst_segments)\n\n # check if we lost the obstacle\n if obst_to_follow is None:\n logger.info(\"BF: Lost obstacle segment; End of Routine\")\n return NavMode.MTG, None\n else:\n # update BF Waypoint\n bf_waypoint.update(obst_to_follow)\n\n # Calculate d_reach, d_followed, v_diff, d_followed_rel\n v_diff = bf_waypoint.get_pos_change()\n d_reach = goal_pos.dist_2d(bf_waypoint.cur_pos)\n assert v_followed is not None and v_diff is not None\n\n v_followed_rel = v_followed + v_diff\n d_followed_rel = v_followed_rel.dist_2d(goal_pos)\n\n # if d_reach < d_followed_rel\n if d_followed_rel - d_reach > config_.D_TOL:\n # switch to MTG\n logger.info(\"BF: path length decreased by %.2f below original minimum; End of Routine\"\n % (d_followed_rel - d_reach))\n return NavMode.MTG, None\n else:\n # choose new BF waypoint\n bf_waypoint = find_new_bf_waypoint(obst_to_follow, cur_pos, None)\n if bf_waypoint is None:\n return NavMode.MTG, None\n\n # generate path to bfWaypoint\n path = [bf_waypoint.cur_pos, goal_pos]\n\n # update v_followed\n v_followed = v_followed_rel\n\n return NavMode.BF, path","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 _choose_algorithm(vehicle, xbee, neighbors):\n if shared.AGENT_CHARACTER == 'square':\n return mas.SquareRoute(vehicle, xbee)\n \n elif shared.AGENT_CHARACTER == 'passive':\n return mas.PassiveLeader(vehicle, xbee)\n \n elif shared.CURRENT_ALGORITHM == 'Vicsek':\n return mas.Vicsek(vehicle, xbee, neighbors)\n \n elif shared.CURRENT_ALGORITHM == 'MPC':\n return mas.Decentralized(vehicle, xbee, neighbors)","def firstNeighbor(v):\n for u in ranks:\n if u in matched or not self.adjacent(u, v):\n continue\n\n return u","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 heuristic_takeDomination(board, player):\n\n boardArray = board.get_board()\n boardSize = board.get_board_size()\n\n otherPlayer = board._WHITE if player is board._BLACK else board._BLACK\n\n score = (board.getCurrentDomination(player) - board.getInitialDomination(player)) * 100\n cst = 30\n\n for corner in board.get_corner():\n if corner is player:\n score += score\n else:\n score -= score\n\n\n\n return score","def nearest_neighbour_heuristic(self, city_count):\n return 1.0 / (500.0 * city_count)","def Neighbors(vendor):\n neighbors = {\"cisco\" : \"\", \"juniper\" : \"\", \"vyatta\" : \"\" }\n cisco_neighbors = {}\n juniper_neighbors = {}\n vyatta_neighbors = {}\n while True:\n print \"***\\t\\t%s NEIGHBORS***\" % (vendor)\n n = raw_input(\"\\t\\tNeighbor information (Press any key to continue. Press 'q' to quit): \")\n if n is not 'q':\n neighbor_id = raw_input(\"\\t\\tNeighbor ID (eg. x.x.x.x): \")\n neighbor_as = raw_input(\"\\t\\tNeighbor AS: \")\n if vendor == \"cisco\":\n cisco_neighbors[neighbor_id] = neighbor_as\n neighbors[vendor] = cisco_neighbors\n elif vendor == \"juniper\":\n juniper_neighbors[neighbor_id] = neighbor_as\n neighbors[vendor] = juniper_neighbors\n else:\n vyatta_neighbors[neighbor_id] = neighbor_as\n neighbors[vendor] = vyatta_neighbors\n else:\n break\n return neighbors","def _get_closest(self, x, y, clients):\n target = min(\n clients,\n key=lambda c: math.hypot(c.x - x, c.y - y),\n default=self.clients.current_client,\n )\n return target","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 nearest_neighbor(FILE_NAME):\n time_0 = DEFAULT_TIMER()\n list_of_cities = read_in_file(FILE_NAME)\n best_opt_distance = sys.maxsize\n best_sol_of_cities = []\n\n for city in list_of_cities: #iterate through all cities in the list\n for resetCity in list_of_cities: #reset them all to not visited\n resetCity[3] = False\n sol_of_cities = [] #set our current solution to empty\n opt_distance = 0 #reset our current optimal solution\n nearest_dist = sys.maxsize #nearest distance is huge\n nearest_city = 0\n first_city = city #the first city visited is the next city in our iteration\n first_city[3] = True\n sol_of_cities.append(first_city[0])\n\n city_1 = first_city\n\n while len(sol_of_cities) < len(list_of_cities): #check the current city to\n #find the closest city in the\n #list of cities not visited\n nearest_dist = sys.maxsize\n for city_2 in list_of_cities:\n #if the two cities are not the same and have not visited the second city\n if city_1[0] != city_2[0] and city_2[3] != True:\n dx = city_1[1] - city_2[1]\n dy = city_1[2] - city_2[2]\n dist_to = int(round(math.sqrt((dx*dx) + (dy*dy))))\n #update nearest_city if the new distance is less than the current nearest distance\n if dist_to < nearest_dist:\n nearest_dist = dist_to\n nearest_city = city_2\n#add the city only if we haven't already visited it. Had a wierd bug need to investigate this further\n if nearest_city[3] != True: \n sol_of_cities.append(nearest_city[0])\n opt_distance += nearest_dist\n nearest_city[3] = True\n city_1 = nearest_city\n #quit if our distance is larger than our best solution found\n if(opt_distance > best_opt_distance):\n #print(\"quit this search\") #comment out, see skipped searches\n break\n#add the distance from the last city we visited back to the first city to make a tour\n dx = nearest_city[1] - first_city[1]\n dy = nearest_city[2] - first_city[2]\n opt_distance += int(round(math.sqrt((dx*dx) + (dy*dy))))\n#if our current solution is better than the previous solution replace it, then start over until we've checked all cities\n if best_opt_distance > opt_distance:\n best_opt_distance = opt_distance\n best_sol_of_cities = sol_of_cities\n #print(best_sol_of_cities) #can remove later for testing now\n #print(best_opt_distance) #same as above\n \n write_to_file(best_sol_of_cities, best_opt_distance, FILE_NAME)\n time_1 = DEFAULT_TIMER()\n print(\"Time taken: \", (time_1 - time_0))","def evaluate_distance(self):\n\n fitness = 0\n routes = split_to_routes(self)\n\n for route in routes:\n route = [home] + route + [home]\n for i in range(1,len(route)):\n # Calculates full distance, including from last city\n # to first, to terminate the trip\n pos_from = route[i - 1]\n pos_to = route[i]\n distance = dm[pos_from][pos_to]\n fitness += distance\n\n return int(fitness)","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 greedy_initial(self):\r\n sol = [] # [[0;2;5;0;4;6;0],[],...]\r\n sol_veh_type = [] # corresponding vehicle type for the solution\r\n route_way_time = []\r\n\r\n to_vist = [i+1 for i in range(store_num - 1)] # [1,5,8,...]\r\n itr = 0\r\n\r\n while len(to_vist) > 0 and itr < 500:\r\n itr += 1\r\n\r\n if itr <= small_veh_cnt:\r\n vehicle_type0 = 2\r\n elif itr <= small_veh_cnt + medium_veh_cnt:\r\n vehicle_type0 = 3\r\n else:\r\n vehicle_type0 = 5\r\n\r\n sol_veh_type.append(vehicle_type0)\r\n\r\n used_res = [0, 0, 0, 0] # used volume, and travel time of the vehicle, leave time, travel distance\r\n veh_rout = [0]\r\n\r\n # print '\\nA new vehicle will be used.'\r\n way_time = 0 # travel time of coming to the store + wait time at the store + operation time at this store\r\n while True:\r\n curr_cust = veh_rout[-1]\r\n\r\n next_one, way_time = self.time_nn(way_time, curr_cust, to_vist, used_res, len(veh_rout), vehicle_type0)\r\n next_cust, next_start = next_one[0], next_one[1]\r\n # print('next start', next_cust, next_start)\r\n if next_cust == 0: # next visiting customer is depot\r\n # print 'Get back to the depot, and ready for a new round.'\r\n veh_rout.append(next_cust)\r\n break\r\n\r\n else: # next visiting customer is a store\r\n used_res[0] += (num_demd[next_cust][0] * bskt_vol + num_demd[next_cust][1] * trsf_vol + (num_demd[next_cust][2] + \\\r\n num_demd[next_cust][3]) * milk_vol + num_demd[next_cust][4] * paper_bskt)\r\n used_res[2] = (next_start + oprt_t)\r\n used_res[3] += dist_mat[curr_cust, next_cust]\r\n\r\n\r\n veh_rout.append(next_cust)\r\n # print 'Vehicle used resource: ', used_res\r\n to_vist.remove(next_cust)\r\n\r\n sol.append(veh_rout)\r\n route_way_time.append(way_time)\r\n\r\n # print 'Last point 0 earliest leave time: ', int(used_res[-1]) / 60, ':', int(used_res[-1]) % 60\r\n # print 'Route %s is: ' % itr, veh_rout\r\n print('*'*10, 'Iteration:', itr, '*'*10)\r\n\r\n\r\n if len(to_vist) > 0:\r\n print('number of stores remained: ', len(to_vist))\r\n\r\n return sol, sol_veh_type, route_way_time","def change_way(coins, opponentLocation, player_location):\n global best_weight, best_path\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(5, coins, player_location, dists_matrix)\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 best_weight = float(\"inf\")\n best_path = []\n api.debug(coins_to_search)\n exhaustive(coins_to_search, player_location, [], 0, dist_matrix)\n meta_route = [player_location] + best_path\n api.debug(meta_route)\n route = u.location_list_to_route(meta_route, route_matrix)\n \n return coins_to_search, meta_route, route, dist_matrix[player_location][meta_route[1]]","def getBoarderGoal(self, gameState):\n boards = self.boarders\n myPos = self.getCurrentObservation().getAgentState(self.index).getPosition()\n if len(boards) > 0:\n dis = 9999\n nearestBoarder = boards[0]\n for b in boards:\n temp = self.getMazeDistance(myPos, b)\n if temp < dis:\n dis = temp\n nearestBoarder = b\n return nearestBoarder, dis\n else:\n return None, None","def pred_car_other_lane(self):\n other_lane = self.other_lane()\n\n for i in range(self.road.N):\n if self.road.cells[other_lane][(self.x + i + 1) % (self.road.N-1)] != -1:\n return self.road.cars[self.road.cells[other_lane][(self.x + i + 1) % (self.road.N-1)]]","def earliest_arrival(jump_distance, stones):\n #jump_distance of 3 means they skip 2 stones and land on 3rd\n stone = ''\n #based on jump_distance, what are all the stone nums within that distance\n #when jump_distance is 5, can jujp to stones[4]\n \n stone = min(stones[:(jump_distance - 1)]) #stone = 2\n\n t = max(0, stone) #t = 2\n print(f't starts at = {t}')\n i = stones.index(stone) # i = 1\n print(f'i starts at = {i}') \n #as long as \n while i + jump_distance <= len(stones) - 1: # 3 + 5 <= 7\n print(f'i + jump_distance = {i + jump_distance}')\n\n stone = min(stones[(i + 1):(i + jump_distance)]) #stone = 3\n print(f'stone: {stone}')\n if t < stone: \n t = stone #reassign to 3\n \n i = stones.index(stone) # i = 2\n print(f'i = {i}') \n stone = min(stones[(i + 1):(i + jump_distance)]) #stone \n t = max(t, stone)\n print(f'end of while loop: t = {t}') \n \n return t\n #what's the lowest num within that jump_distance \n #go to that stone, then look at next stones in new jump_distance\n #t becomes whatever stone we jumped to\n #if the next stone we jump to is a higher value, reassign t\n #get length of list of stones so we don't go past length\n #var assigned to len(list) and compare to index we're at \n #if index we're jumping to is higher than len of list, then we're done\n #control for indexerror with while loop?\n # ","def dimitra_dispersy_get_walk_candidate(self):\n # 13/02/12 Boudewijn: normal peers can not be visited multiple times within 30 seconds,\n # bootstrap peers can not be visited multiple times within 55 seconds. this is handled by\n # the Candidate.is_eligible_for_walk(...) method\n\n assert all(not sock_address in self._candidates for sock_address in self._dispersy._bootstrap_candidates.iterkeys()), \"none of the bootstrap candidates may be in self._candidates\"\n\n from sys import maxint\n\n now = time()\n categories = [(maxint, None), (maxint, None), (maxint, None)]\n category_sizes = [0, 0, 0]\n\n for candidate in self._candidates.itervalues():\n if candidate.is_eligible_for_walk(now):\n category = candidate.get_category(now)\n if category == u\"walk\":\n categories[0] = min(categories[0], (candidate.last_walk, candidate))\n category_sizes[0] += 1\n elif category == u\"stumble\":\n categories[1] = min(categories[1], (candidate.last_stumble, candidate))\n category_sizes[1] += 1\n elif category == u\"intro\":\n categories[2] = min(categories[2], (candidate.last_intro, candidate))\n category_sizes[2] += 1\n\n walk, stumble, intro = [candidate for _, candidate in categories]\n while walk or stumble or intro:\n r = pythonrandlib.random()\n\n # 13/02/12 Boudewijn: we decrease the 1% chance to contact a bootstrap peer to .5%\n if r <= .4975: # ~50%\n if walk:\n logger.debug(\"returning [%2d:%2d:%2d walk ] %s\", category_sizes[0] , category_sizes[1], category_sizes[2], walk)\n return walk\n\n elif r <= .995: # ~50%\n if stumble or intro:\n while True:\n if pythonrandlib.random() <= .5:\n if stumble:\n logger.debug(\"returning [%2d:%2d:%2d stumble] %s\", category_sizes[0] , category_sizes[1], category_sizes[2], stumble)\n return stumble\n\n else:\n if intro:\n logger.debug(\"returning [%2d:%2d:%2d intro ] %s\", category_sizes[0] , category_sizes[1], category_sizes[2], intro)\n return intro\n\n # else: # ~.5%\n # candidate = self._bootstrap_candidates.next()\n # if candidate:\n # logger.debug(\"returning [%2d:%2d:%2d bootstr] %s\", category_sizes[0] , category_sizes[1], category_sizes[2], candidate)\n # return candidate\n\n bootstrap_candidates = list(self._iter_bootstrap(once=True))\n pythonrandlib.shuffle(bootstrap_candidates)\n for candidate in bootstrap_candidates:\n if candidate:\n logger.debug(\"returning [%2d:%2d:%2d bootstr] %s\", category_sizes[0] , category_sizes[1], category_sizes[2], candidate)\n \n logger.debug(\"no candidates or bootstrap candidates available\")\n return None","def search_next_win(self, player):\n for i, j, k in self.winning_cases:\n if self.game_board[i] == player and \\\n self.game_board[j] == player and \\\n self.game_board[k] == ' ':\n return k\n elif self.game_board[j] == player and \\\n self.game_board[k] == player and \\\n self.game_board[i] == ' ':\n return i\n elif self.game_board[i] == player and \\\n self.game_board[k] == player and \\\n self.game_board[j] == ' ':\n return j\n return None","def transit_next(self, vehicle, time):\n events = []\n vehicle.current += 1\n cur_stop = vehicle.route[vehicle.current]\n\n # pickup passengers\n trip_id = vehicle.id.split('_')[0]\n for (end_stop, action) in self.stops[cur_stop['stop_id']][trip_id]:\n logger.debug('[{}] {} Picking up passengers at {}'.format(time, vehicle.id, cur_stop['stop_id']))\n vehicle.passengers[end_stop].append(action)\n self.stops[cur_stop['stop_id']][trip_id] = []\n\n # dropoff passengers\n for action in vehicle.passengers[cur_stop['stop_id']]:\n logger.debug('[{}] {} Dropping off passengers at {}'.format(time, vehicle.id, cur_stop['stop_id']))\n events.extend(action(time))\n vehicle.passengers[cur_stop['stop_id']] = []\n\n try:\n next_stop = vehicle.route[vehicle.current + 1]\n except IndexError:\n # trip is done\n return events\n\n # schedule next leg of trip\n time = next_stop['arr_sec'] - cur_stop['dep_sec']\n events.append((time, partial(self.transit_next, vehicle)))\n return events","def next_player(board, prev_player):\n opp = Othello.opponent(prev_player)\n if Othello.any_legal_move(opp, board):\n return opp\n elif Othello.any_legal_move(prev_player, board):\n return prev_player\n return None","def computer_driver_heuristic(self, pc):\n if pc == self.departure_location:\n return self.nearest_neigbor(pc)\n else:\n # encode state: State -> Generalized One hot vector\n # print(len(self.idx_to_pc)+1)\n encoded_vector = np.zeros(len(self.idx_to_pc)+1)\n\n # indices of locations FOR ENCODING\n pickup_jobs_idx = [self.pc_to_idx[p]+1 for p in list(self.state.P_k.keys())] # +1 is to make room for the time dim\n deliv_jobs_idx = [self.pc_to_idx[p]+1 for p in list(self.state.D_k.keys())]\n\n # indices of locations FOR PC READING\n pickup_jobs_idx_read = [self.pc_to_idx[p] for p in list(self.state.P_k.keys())]\n deliv_jobs_idx_read = [self.pc_to_idx[p] for p in list(self.state.D_k.keys())]\n tasks = set(pickup_jobs_idx_read + deliv_jobs_idx_read)\n\n if len(tasks) > 0:\n # set appropriate values at the index corresponding to the location\n encoded_vector[pickup_jobs_idx] = -0.5\n encoded_vector[deliv_jobs_idx] = 0.5\n encoded_vector[self.pc_to_idx[pc]+1] = 1\n\n # # current time encoded as nb of seconds between 12pm and now/nb seconds between 12pm and 12am\n total_nb_seconds = datetime.timedelta(hours=12, minutes=0)\n cur_time = self.state.t_k.time()\n cur_time = datetime.timedelta(hours=cur_time.hour, minutes=cur_time.minute) # nb of seconds from 12am\n # # TODO this can further be noramlized as most values will be >0 (>6am)\n cur_time = 2 * cur_time.seconds / total_nb_seconds.seconds - 1 # normalized time in [-1,1]\n encoded_vector[0] = cur_time\n\n # predict decision\n pred = self.heuristic_model.predict_proba(encoded_vector.reshape(1,-1))\n\n # take the most probable location among the remaining jobs\n # # set proba to 0 if location not among remaining jobs\n # print(\"##############\")\n # print(\"shape of pred \", pred.shape)\n # print(\"Number of locations considered : \", len(self.idx_to_pc))\n print(\"Possible indices to choose from : \", tasks)\n pred[0, list(set(range(0, len(self.idx_to_pc))) - set(pickup_jobs_idx_read + deliv_jobs_idx_read))] = 0\n\n idx_opt = np.argsort(pred[0,:])[-1] # most probable location (by its index) among remaining jobs\n print(\"Index chosen : \", idx_opt )\n return self.idx_to_pc[idx_opt]\n\n elif len(tasks) == 0:\n return 0\n\n else:\n raise ValueError('Problem with tasks, which has negative length...')","def _get_next_cheapest_desired_card(diff_state):\n # search for min within in Dict\n # may optimize later\n\n next_card = CardEnum.NoCard\n min_cost = 1e6 # Arbitrarily Large Number\n\n for key in list(diff_state.keys()):\n if diff_state[key] is not None:\n if diff_state[key] < min_cost:\n next_card = key\n min_cost = diff_state[key]\n\n return next_card","def find_route(risk_map: MAP, destination: COORDINATE) -> int:\n # Time for some Dijkstra! https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm\n # Per the problem description cost is added when a position is entered, so we start at 0\n heap = [(0, (0, 0))] # distance (risk), node\n min_risk = defaultdict(lambda: math.inf, {(0, 0): 0})\n seen = set()\n while heap:\n # Use heapq, as we want to select the next unvisited node with the lowest potential distance\n risk, node = heappop(heap)\n\n if node == destination:\n return risk\n\n if node in seen:\n continue\n\n # For each node we visit, we check its unvisited neighbors & find the shortest distance\n # (risk) to the starting node & update the current node accordingly\n seen.add(node)\n for neighbor_coord in iter_neighbors(*node):\n if neighbor_coord not in risk_map:\n continue\n\n tentative_risk = risk + risk_map[neighbor_coord]\n if tentative_risk < min_risk[neighbor_coord]:\n min_risk[neighbor_coord] = tentative_risk\n heappush(heap, (tentative_risk, neighbor_coord))","def find_destination_hub_and_leg_travel_time(destination):\n milk_run_shipments = create_shipments_milk_run()\n for shipment in milk_run_shipments:\n for dest in shipment.milk_run.split('-'):\n if dest == destination:\n return shipment.hub, shipment.travel_time\n return 'not found', 0","def next_candidate():\r\n candidate_bidder = -1\r\n candidate_value = -1\r\n for n in range(len(bidders)):\r\n if (is_active[n] == 0 and cur_value(n) is not None\r\n and cur_value(n) > max(candidate_value, cur_bid)):\r\n candidate_value = bidders[n].values[cur_value_idx[n]]\r\n candidate_bidder = n\r\n return candidate_value, candidate_bidder","def search_best_goal_node(self):\n\n dist_to_goal_list = [self.calc_dist_to_goal(n.x, n.y) for n in self.node_list]\n goal_indexes = [\n dist_to_goal_list.index(i)\n for i in dist_to_goal_list\n if i <= self.expand_dis\n ]\n\n safe_goal_indexes = []\n for goal_index in goal_indexes:\n t_node = self.steer(self.node_list[goal_index], self.goal_node)\n if self.check_collision(t_node, self.obstacle_list):\n safe_goal_indexes.append(goal_index)\n\n if not safe_goal_indexes:\n return None\n\n min_cost = min([self.node_list[i].cost for i in safe_goal_indexes])\n for i in safe_goal_indexes:\n if self.node_list[i].cost == min_cost:\n return i\n\n return None","def find_next(i, low, high):\n print(\"Searching from {} to {}...\".format(low, high))\n if low == high:\n set_search_addr(i, low)\n response = i.send(Compare())\n\n if response.value is True:\n print(\"Found ballast at {}; withdrawing it...\".format(low))\n i.send(Withdraw())\n return low\n return None\n\n set_search_addr(i, high)\n response = i.send(Compare())\n\n if response.value is True:\n midpoint = (low + high) // 2\n return find_next(i, low, midpoint) or find_next(i, midpoint + 1, high)","def _next_action(self) -> SingleBriberyAction:\n self._current_rating = self.get_graph().eval_graph(self.get_briber_id())\n if self._previous_rating is None:\n self._previous_rating = self._current_rating\n next_act = SingleBriberyAction(self)\n try:\n self._next_node = self.get_graph().get_random_customer(excluding=self._info_gained | self._bribed)\n except IndexError:\n print(f\"WARNING: {self.__class__.__name__} found no influential nodes, not acting...\", file=sys.stderr)\n return next_act\n if self._current_rating - self._previous_rating > self._max_rating_increase:\n self._best_node = self._last_node\n self._max_rating_increase = self._current_rating - self._previous_rating\n maximum_bribe = min(self.get_resources(), self._bribe_to_max())\n if self._c >= self._i and self._best_node is not None and maximum_bribe > 0:\n next_act.add_bribe(self._best_node, maximum_bribe)\n self._bribed.add(self._best_node)\n self._info_gained = set()\n self._c = 0\n self._max_rating_increase = 0\n self._best_node = 0\n else:\n if self._c >= self._i:\n print(f\"WARNING: {self.__class__.__name__} has not found an influential node in {self._c} tries \"\n f\"(intended maximum tries {self._i}), continuing search...\",\n file=sys.stderr)\n # Bid an information gaining bribe, which is at most k, but is\n # smaller if you need to bribe less to get to the full bribe\n # or don't have enough money to bid k.\n next_act.add_bribe(self._next_node, min(self._bribe_to_max(), min(self.get_resources(), self._k)))\n self._info_gained.add(self._next_node)\n self._c = self._c + 1\n self._last_node = self._next_node\n self._previous_rating = self._current_rating\n return next_act","def __get_next_visit_node(self) -> str:\r\n node = None\r\n\r\n for visit in self.__priority_queue:\r\n # We can't visit the start node\r\n if visit.node_name == self.__fr:\r\n continue\r\n\r\n # Finds the lowest value node\r\n if node is None or visit.cost < node.cost:\r\n node = visit\r\n\r\n return node.node_name","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 find_next_step(start, end, paths):\r\n def find_paths(start, current, distance, paths, choices):\r\n \"\"\"\r\n Given the start point, and the current point, builds a dictionary indicating the first step\r\n and the minimum distance to the end using that step. Distance indicates the distance from\r\n current to end.\r\n \"\"\"\r\n # Find all paths resulting in the minimum distance\r\n options = []\r\n min_distance = min(paths[current].values())\r\n for option, distance in paths[current].items():\r\n if distance == min_distance:\r\n\r\n # If we find the beginning, break out\r\n if option == start:\r\n if option not in choices or choices[current] < distance + min_distance:\r\n choices[current] = distance + min_distance\r\n return\r\n\r\n # Add to list of options\r\n options.append(option)\r\n\r\n # For each path, recursively find minimal paths\r\n for option in options:\r\n find_paths(start, option, min_distance, paths, choices)\r\n\r\n choices = {}\r\n find_paths(start, end, 0, paths, choices)\r\n choices = sorted(choices.keys())\r\n return choices[0]","def getNextWaypoint(self, request, context):\n\n waypointNumber = self.vehicle.commands.next -1\n missionlist = self.vehicle.waypoints\n if len(missionlist)==0:\n waypointNumber = -1\n dronePosition = droneconnect_pb2.Position(lat = float(0),\n lon = float(0),\n gpsAltitude = float(0))\n else:\n waypoint = missionlist[waypointNumber]\n dronePosition = droneconnect_pb2.Position(lat = float(waypoint[0]),\n lon = float(waypoint[1]),\n gpsAltitude = float(waypoint[2]))\n \n return droneconnect_pb2.IndexedPosition(position = dronePosition, index = waypointNumber)","def get_next_departure(self,day,link,current_time): \n if link not in self.data[day]:\n return None\n import numpy as np\n index=[np.searchsorted(self.data[day][link][0:,0],current_time)]\n print(len(self.data[day][link]))\n print(index) \n if index[0] < len(self.data[day][link]):\n return self.data[day][link][index[0]]\n else:\n return None","def check_directions(next_door, current_node, goal_node, chip, crossroad, travelled_path, colide): \n if next_door[2] < 0 or next_door[2] > 7:\n return crossroad\n\n # Check if the node is off the grid\n if next_door[0] < 0 or next_door[0] > chip.width - 1 or next_door[1] < 0 or next_door[1] > chip.height - 1:\n return crossroad\n\n (x, y, z) = current_node.position\n\n # Check whether a connection is already being used\n if chip.coordinates[z][y][x].connections[next_door].used:\n return crossroad\n\n next_node = chip.coordinates[next_door[2]][next_door[1]][next_door[0]]\n\n neighbour = nd.Node(next_door, current_node, next_node.cost, next_node.cost + next_node.distance_to_goal)\n\n if neighbour != goal_node and chip.coordinates[next_door[2]][next_door[1]][next_door[0]].gate is not None:\n return crossroad\n\n # Check whether the coordinate is already in the current path.\n if neighbour in travelled_path:\n return crossroad\n\n # Check whether neighbor is in open list and if it has a lower cost value\n if add_to_crossroad(neighbour, crossroad, colide):\n crossroad.append(neighbour)\n\n return crossroad","def nearest_neighbor(A, cities):\n return min(cities, key = lambda c: distance(c,A))","def findDJI(startVert, endVert): \n\n dist = {}\n dist[startVert] = 0\n prev = {}\n prev[startVert] = None\n q = heap.Heap()\n q.insert(startVert, dist[startVert])\n while (q):\n # current is the next unvisited, closest node to start\n current = q.pop()\n \n # check to see if we found a better path to any\n # of current's neighbors\n for n in current.getConnections():\n if n not in dist:\n # we found a new node\n dist[n] = dist[current] + current.getWeight(n)\n prev[n] = current\n q.insert(n, dist[n])\n if dist[current] + current.getWeight(n) < dist[n]:\n # we found a better path\n dist[n] = dist[current] + current.getWeight(n)\n prev[n] = current\n q.decreaseKey(n, dist[n])\n if endVert in dist:\n return backtrack(startVert, endVert, prev)\n else:\n return None","def find_best_match(organ: Organ, wait_list: WaitList,\n weights: Dict[int, float]) -> Optional[Patient]:\n # ANSI codes to emphasize output\n bold_red, red, reset = '\\033[31;1m', '\\033[31m', '\\033[0m'\n matches = wait_list.get_prioritized_patients(organ)\n\n # returns the patient with the highest priority within acceptable proximity\n while len(matches) != 0:\n patient = heapq._heappop_max(matches) # type: ignore\n if organ.viability >= weights[patient.location] - 10:\n return patient\n\n # in the event there are no matches\n print(f'\\n{bold_red}The following organ has no suitable matches:'\n f'\\n{red}{organ.__str__()}{reset}')\n return None","def _distance_next(self):\n\n self.distance = 10\n\n # Here a set index to 0 if the car is finishing a lap\n # Also reset the farthest\n if self.index > (len(self.x_trajectory) - 6) and self.closed:\n self.index = 0\n self.farthest = -1\n self.laps += 1\n\n for w in range(self.index, self.index + 20):\n\n self.dist_point = math.sqrt((self.x_trajectory[w] - self.x)**2\n + (self.y_trajectory[w] - self.y)**2)\n\n if self.dist_point < self.distance:\n self.distance = self.dist_point\n self.index = w\n\n if w >= (len(self.x_trajectory) - 1):\n break\n\n self._calc_side()\n\n self.distance = self.distance * self.sign\n\n return self.distance"],"string":"[\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 create_single_customer_route(customer: int) -> Route:\\n problem = Problem()\\n\\n # After depot, and after customer: two configurations in total.\\n stacks = [Stacks(problem.num_stacks) for _ in range(2)]\\n\\n # We place the deliveries and pickups in the shortest stack - this\\n # does not really matter much, as each stack is empty at this point\\n # anyway.\\n stacks[0].shortest_stack().push_rear(problem.demands[customer])\\n stacks[1].shortest_stack().push_rear(problem.pickups[customer])\\n\\n return Route([customer], stacks)\",\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 get_known_customer(name: str, address: str, customers: List[Customer], visit: bool=True) -> Optional[Customer]:\\n\\n for customer in customers:\\n if customer.name == name and customer.address == address:\\n customer.visit = visit\\n return customer\\n \\n # No such customer found.\\n return None\",\n \"def heuristic_function(self, node_current: PriorityNode) -> float:\\n ########################################################################\\n # todo: Implement your own heuristic cost calculation here. #\\n # Hint: #\\n # Use the State of the current node and the information from the #\\n # planning problem, as well as from the scenario. #\\n # Some helper functions for your convenience can be found in #\\n # ./search_algorithms/base_class.py #\\n ########################################################################\\n output_logs = False\\n if output_logs:\\n print(\\\"##################\\\")\\n print(\\\"current time step: \\\", node_current.list_paths[-1][-1].time_step)\\n print(\\\"current problem mode\\\", self.planningProblemType)\\n print(\\\"depth tree: \\\", node_current.depth_tree)\\n currentorient = node_current.list_paths[-1][-1].orientation\\n currentpos = node_current.list_paths[-1][-1].position\\n currenttimestep = node_current.list_paths[-1][-1].time_step\\n currentVel = node_current.list_paths[-1][-1].velocity\\n\\n # Test if reached goal:\\n if self.reached_goal(node_current.list_paths[-1]):\\n return 0.0\\n # Test if route planner failed to find a path: \\n if self.routeplannerresult is None:\\n return np.inf\\n\\n ############ Detect cars in front:\\n # calc cost based on distance to gool following the refrence path:\\n # loop through all obstacles at time step x and find if any is close of current pos:\\n if not self.disableObstAvoidance:\\n for obst in self.list_obstacles:\\n obstPos = obst.state_at_time(currenttimestep)\\n if currentorient is not None and obstPos is not None:\\n disttoobst = self.euclidean_distance(currentpos, obstPos.position)\\n lookaheadVar = 1.375 * currentVel + 2.5\\n if disttoobst <= lookaheadVar:\\n # calc orientation diff between car and obstacle:\\n vectorToObst = np.array([currentpos, obstPos.position])\\n vectorToObstOrient = self.calc_angle_of_position(vectorToObst, currentpos)\\n orientdiff = self.calc_orientation_diff(currentorient, vectorToObstOrient)\\n if abs(orientdiff) <= 0.261799:\\n if not 'velocity' in obstPos.attributes:\\n continue\\n if node_current.list_paths[-1][-1].velocity > obstPos.velocity and obstPos.velocity != 0:\\n return np.inf\\n \\n # get index of closest object to the ego vehicle:\\n index_smallest_dist = self.get_index_nearest_obst_infront(node_current)\\n \\n # use the index to locate vehicle to calc cost: \\n if index_smallest_dist != -1:\\n # found the index of vehicle with smallest distance to ego car:\\n obst = self.list_obstacles[index_smallest_dist]\\n obstPos = obst.state_at_time(currenttimestep)\\n if obstPos is not None and 'velocity' in obstPos.attributes:\\n if obstPos.velocity == 0:\\n cost = node_current.list_paths[-1][-1].velocity\\n return cost\\n if node_current.list_paths[-1][-1].velocity > obstPos.velocity:\\n return np.inf\\n cost = abs(node_current.list_paths[-1][-1].velocity - obstPos.velocity)\\n return cost\\n #########################################################\\n\\n # Decide based on planning problem type how to calculate cost\\n if self.planningProblemType == 'ModeA':\\n # Call function for planning problem with desired time, position, speed and orientation\\n cost = self.cost_for_modeA_problem(node_current, output_logs)\\n if output_logs:\\n print(\\\"Cost from modeA cost func: \\\", cost)\\n if cost < 0:\\n return 0\\n return cost\\n elif self.planningProblemType == 'ModeB':\\n # Call function for planning problem with desired time, position and velocity:\\n cost = self.cost_for_modeB_problem(node_current, output_logs)\\n if output_logs:\\n print(\\\"Cost from modeB cost func: \\\", cost)\\n if cost < 0:\\n return 0\\n return cost\\n elif self.planningProblemType == 'ModeC':\\n # Call function for planning problem with desired time, position and orientation:\\n cost = self.cost_for_modeC_problem(node_current, output_logs)\\n if output_logs:\\n print(\\\"Cost from modeB cost func: \\\", cost)\\n if cost < 0:\\n return 0\\n return cost\\n elif self.planningProblemType == 'ModeD':\\n # Call function for planning problem with desired time and position:\\n cost = self.cost_for_modeD_problem(node_current, output_logs)\\n if output_logs:\\n print(\\\"Cost from modeB cost func: \\\", cost)\\n if cost < 0:\\n return 0\\n return cost\\n elif self.planningProblemType == 'Survival':\\n # Call function for planning problem with desired time:\\n cost = self.cost_for_Survival_problem(node_current, output_logs)\\n if output_logs:\\n print(\\\"Cost from modeB cost func: \\\", cost)\\n if cost < 0:\\n return 0\\n return cost\",\n \"def solve(customerCount, vehicleCount, vehicleCapacity, depotIndex, customers):\\n \\n N, locations, locations_r, distances, closest = precalculate(customers)\\n \\n #print locations\\n #print locations_r\\n angle_order = range(1, N)\\n angle_order.sort(key=lambda i: (locations_r[i, 1], locations_r[i, 0])) \\n \\n vehicleTours = best_order(customerCount, customers, vehicleCount, vehicleCapacity, angle_order)\\n if not vehicleTours:\\n vehicleTours = solve0(customerCount, vehicleCount, vehicleCapacity, depotIndex, customers)\\n check(customerCount, customers, vehicleCapacity, vehicleTours)\\n vehicleTours = get_shortest_paths('file_path XXX', customers, depotIndex, vehicleTours)\\n check(customerCount, customers, vehicleCapacity, vehicleTours)\\n \\n vehicleTours0 = copy.deepcopy(vehicleTours)\\n dist0 = total_dist(customers, depotIndex, vehicleTours)\\n if False:\\n for _ in range(100):\\n vehicleTours = copy.deepcopy(vehicleTours0) \\n adjust_tours(customers, vehicleCapacity, vehicleCount, vehicleTours)\\n vehicleTours = get_shortest_paths('file_path XXX', customers, depotIndex, vehicleTours)\\n #check(customerCount, customers, vehicleCapacity, vehicleTours)\\n if not is_valid(customerCount, customers, vehicleCapacity, vehicleTours):\\n continue\\n dist = total_dist(customers, depotIndex, vehicleTours)\\n if dist < dist0:\\n print '%s => %s' % (dist0, dist)\\n vehicleTours0 = vehicleTours[:]\\n dist0 = dist\\n \\n \\n vehicleTours = copy.deepcopy(vehicleTours0) \\n check(customerCount, customers, vehicleCapacity, vehicleTours)\\n while len(vehicleTours) < vehicleCount:\\n vehicleTours.append([])\\n \\n print '*', vehicleTours \\n \\n return vehicleTours\",\n \"def determineNextMove(playerLocation, opponentLocation, coins):\\n global packages, route_table, best_path, best_weight, route\\n if len(best_path) == 0:\\n current_package = packages.pop(0)\\n exhaustive(current_package, playerLocation, [], 0, (route_table,dists))\\n api.debug(best_path)\\n return u.direction(playerLocation, best_path.pop(0))\",\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 next_car(schedule, travel_time):\\n\\n #travel_time = datetime.datetime.strptime(datetime.datetime.strptime(travel_time, '%Y-%m-%d %H:%M:%S').strftime('%H:%M:%S'), '%H:%M:%S')\\n next_time = None\\n\\n for index, time in enumerate(schedule):\\n if time.is_after(travel_time):\\n next_time = index\\n break\\n #time = datetime.datetime.strptime(time, '%H:%M:%S')\\n ## total_seconds is negative if travel_time is upper than time in schedule\\n ## if its possible to get car when arrived at the same time it go to next stop\\n ## just use >= instead of >\\n #if (time - travel_time).total_seconds() > 0:\\n ##print('SÉÉ:', time.__class__, time)\\n ##print('SÉÉ:', travel_time.__class__, travel_time)\\n ##print(time - travel_time)\\n ##print('AUI:', travel_time - time, (travel_time - time).total_seconds())\\n ##print('RET:', time)\\n #next_time = index\\n #break\\n\\n return 0 if next_time is None else next_time\",\n \"def greedy_selector(self):\\n r_k = 0 \\n best_route = []\\n cities_to_visit = [i for i in range(1, self.city_count)]\\n for _ in range(1, self.city_count):\\n s_ind = np.argmax([self.tau[(r_k, u)] for u in cities_to_visit])\\n s_k = cities_to_visit.pop(s_ind)\\n best_route.append((r_k, s_k))\\n r_k = s_k\\n best_route.append((r_k, 0))\\n \\n shortest_path = np.sum([self.phi[(p)] for p in best_route])\\n return best_route, shortest_path\",\n \"def calculate_random_move(self, vehicleamount, visit):\\n self.depth += 1\\n\\n while True:\\n number = (randint(0, 1))\\n vehicle_id = (randint(0, vehicleamount-1))\\n vehicle = self.vehicles[vehicle_id]\\n state = self.get_board()\\n if vehicle.orientation == 0: #horizontal\\n if number == 0:\\n if vehicle.x > 0: #left\\n if state[vehicle.y][vehicle.x-1] == \\\"..\\\":\\n self.vehicles[vehicle_id].x -=1\\n if self.get_board().tostring() in visit:\\n self.vehicles[vehicle_id].x += 1\\n else:\\n return self\\n else:\\n if vehicle.x + vehicle.length <= (len(state)-1): #right\\n if state[vehicle.y][vehicle.x+vehicle.length] == \\\"..\\\":\\n self.vehicles[vehicle_id].x += 1\\n if self.get_board().tostring() in visit:\\n self.vehicles[vehicle_id].x -= 1\\n else:\\n return self\\n else: #vertical\\n if number == 0:\\n if vehicle.y - 1 >= 0: #up\\n if state[vehicle.y-1][vehicle.x] == \\\"..\\\":\\n self.vehicles[vehicle_id].y -= 1\\n if self.get_board().tostring() in visit:\\n self.vehicles[vehicle_id].y += 1\\n else:\\n return self\\n else:\\n if vehicle.y + vehicle.length <= (len(state)-1):\\n if state[vehicle.y + vehicle.length][vehicle.x] == \\\"..\\\":#down\\n self.vehicles[vehicle_id].y += 1\\n if self.get_board().tostring() in visit:\\n self.vehicles[vehicle_id].y -= 1\\n else:\\n return self\",\n \"def next_node(self):\\r\\n to_visit = list(self.to_visit())\\r\\n if not to_visit:\\r\\n return None\\r\\n next_up = min(to_visit, key=lambda n: self.table[n][\\\"dist\\\"])\\r\\n connected = self.table[next_up][\\\"dist\\\"] != float(\\\"inf\\\")\\r\\n return next_up if connected else None\",\n \"def neirest_neighbour(business, cells):\\n array = cells.get_neighbours(business, num=1)\\n neighbours = pd.DataFrame(array).set_index('index')\\n index = neighbours['distance'].idxmin()\\n return neighbours.loc[index]\",\n \"def getNext(self, carPos):\\n if carPos.lane != self:\\n print \\\"car is on other lane\\\"\\n return []\\n next = []\\n shortestDist = sys.maxint\\n for car in self.carsPosition.itervalues():\\n if car.isGoalFlag:\\n next.append(car)\\n continue\\n if car.position is None:\\n print \\\"the car has no position\\\"\\n continue\\n if car.car.id == carPos.car.id:\\n continue\\n distance = car.position - carPos.position\\n if not car.free and (0 < distance < shortestDist): # only pick the cars in front of current car\\n shortestDist = distance\\n next.append(car)\\n return next\",\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 exhaustive_search(city_list,until):\\n all_tours = recursive_travel(city_list[0:until])\\n shortest = shortest_tour(all_tours)\\n return shortest\",\n \"def nearest_neigbor(self, pc):\\n coord = get_coordinates(pc)\\n # deliveries\\n pdist_deliv = {haversine(coord[0], coord[1], pcoord[1][0], pcoord[1][1]):pc for pc, pcoord in self.state.D_k.items()}\\n pdist_list_deliv = list(pdist_deliv.keys())\\n if len(pdist_list_deliv) > 0:\\n val_deliv_min = min(pdist_list_deliv)\\n else:\\n val_deliv_min = 1e6 # great value to be discarded when comparing with val_pickup_min\\n # pickups\\n pdist_pickup = {haversine(coord[0], coord[1], pcoord[-1][0], pcoord[-1][1]):pc for pc, pcoord in self.state.P_k.items()}\\n pdist_list_pickup = list(pdist_pickup.keys())\\n\\n if len(pdist_list_pickup) > 0:\\n val_pickup_min = min(pdist_list_pickup)\\n else:\\n val_pickup_min = 1e6 # great value to be discarded when comparing with val_pickup_min\\n\\n if val_deliv_min == val_pickup_min and val_deliv_min == 1e6:\\n print(\\\"All jobs completed: go to wait or stop if it's 12pm\\\")\\n return 0\\n\\n if val_deliv_min < val_pickup_min:\\n return pdist_deliv[val_deliv_min]\\n\\n elif val_deliv_min >= val_pickup_min:\\n return pdist_pickup[val_pickup_min]\\n else:\\n raise valueError('Impossible comparison between val_deliv_min and val_pickup_min ')\",\n \"def get_cheapest_neighbor(client, facilities):\\n adj_facilities = client.get_facility_list(facilities)\\n return min(adj_facilities, key=lambda fac: fac['cost'])\",\n \"def choose_next(garden, pos):\\n\\n north = garden[pos[0] - 1][pos[1]] if pos[0] != 0 else -1\\n south = garden[pos[0] + 1][pos[1]] if pos[0] != len(garden)-1 else -1\\n east = garden[pos[0]][pos[1]+1] if pos[1] != len(garden[pos[0]])-1 else -1\\n west = garden[pos[0]][pos[1]-1] if pos[1] != 0 else -1\\n\\n # I'm sure there is a shorter way for these as well\\n max_val = max(north, south, east, west)\\n next_pos = None\\n if max_val == 0: # No more adjacent carrots\\n next_pos == None\\n elif max_val == north:\\n next_pos = (pos[0] - 1, pos[1])\\n elif max_val == south:\\n next_pos = (pos[0] + 1, pos[1])\\n elif max_val == east:\\n next_pos = (pos[0], pos[1] + 1)\\n elif max_val == west:\\n next_pos = (pos[0], pos[1] - 1)\\n\\n return next_pos\",\n \"def doRide(car, ride):\\n global MAX_DISTANCE_START, MAX_DISTANCE_FINISH\\n (a, b, x, y, s, f) = ride\\n lenght_ride = abs(x - a) + abs(y - b)\\n # Simple heuristic to make it faster\\n if lenght_ride > MAX_DISTANCE_FINISH: # So it doesn't take too long rides\\n return None\\n if car is None or len(car) == 0: # No car or no rides asigned to the car\\n (cx, cy) = INITIAL_POS\\n cs = INITIAL_TIME\\n else: # Else, look in the list\\n last_ride = car[-1]\\n (cx, cy) = tuple(rides[last_ride][0:2]) # Position of the car\\n # When will the car be at that position\\n cs = rides_done[last_ride][2]\\n # Distance to the ride's starting intersection\\n distance = abs(cx - a) + abs(cy - b)\\n if distance > MAX_DISTANCE_START: # Do not take too far away ones\\n return None\\n when = max(cs + distance, s)\\n if when + lenght_ride > f: # The car cant make it\\n return None\\n\\n return when, when + lenght_ride, when == s\",\n \"def get_next_unvisited(visited, shortest_paths):\\n min_dist = math.inf\\n min_node = None\\n for node_id in shortest_paths:\\n dist = shortest_paths[node_id][0]\\n if dist < min_dist and visited[node_id] == False:\\n min_dist = dist\\n min_node = node_id\\n return min_node\",\n \"def kPaths(veh, currentEdge):\\n # A set of all of the edges, used to reset the vehicle's internal estimated edge store\\n edgesSet = set()\\n k = 1\\n # This is a fail safe in case there are less paths than K_MAX available for the vehicle to take\\n timeOut = 0\\n\\n # Finding the best possible route for the vehicle\\n traci.vehicle.rerouteTraveltime(veh, currentTravelTimes=False)\\n\\n # The vehicle's current route\\n bestRoute = traci.vehicle.getRoute(veh)\\n # Element of the current edge within the currentRoute\\n currentEdgeIndex = bestRoute.index(currentEdge)\\n # Altered route with the first element of the route being the current edge\\n currentRoute = bestRoute[currentEdgeIndex:]\\n edgesSet.update(currentRoute)\\n\\n # Recording down the current best route and time\\n bestTime = sim.getGlobalRoutePathTime(currentRoute)\\n routes = {}\\n routes['{}_best'.format(k)] = (bestTime, currentRoute,)\\n\\n # This records the estimated travel time for each road segment in which the vehicle may take (with or without\\n # penalisation applied) -- this is done on and reset on a vehicle-per-vehicle basis\\n adjustedEdgeVehicle = {}\\n for edge in currentRoute:\\n adjustedEdgeVehicle[edge] = edgeSpeedGlobal[edge]\\n\\n # Creating up to k-1 additional routes\\n while k < K_MAX:\\n penalisePathTimeVehicle(veh, currentRoute, adjustedEdgeVehicle)\\n\\n traci.vehicle.rerouteTraveltime(veh, currentTravelTimes=False)\\n newRoute = traci.vehicle.getRoute(veh)\\n currentRoute = newRoute[currentEdgeIndex:]\\n newRouteTime = sim.getGlobalRoutePathTime(currentRoute)\\n\\n # These are the routes which have already been selected\\n currentEligibleRoutes = [x[1] for x in routes.values()]\\n # Ensuring the route doesn't exist within the existing eligible routes, the route contains the edge in which the\\n # vehicle is currently occupying, and the route is not currently the best route\\n if currentRoute not in currentEligibleRoutes and currentEdge in currentRoute:\\n timeOut = 0\\n # This keeps track if the calculated 'best' route time is above that of the calculated new route time\\n bestRouteMoreThanNewRouteTime = False\\n\\n \\\"\\\"\\\"\\n Sometimes the roads suffer so much congestion that there are issues with reliable estimation of travel\\n times given by TraCI. TraCI may sometimes give overblown estimations of the travel times of an edge, for\\n example if the edge is being blocked and no movement is being made, the estimated time may be \\n disproportionally large compared to it's real-world equivalent predicted time taken; this problem persists\\n even with a rerouting device being connected to the vehicles which allows for more accurate 'smoothed' \\n aggregated travel times- this is a fault inherent to TraCI. \\n \\n In an attempt to alleviate this, the estimated travel times are bounded to 15x their free-flow speed. \\n However, this sometimes causes the best time to no longer be the best time depending on the number of \\n edge travel time boundings in a route (which could alter the predicted time for a route given we are \\n now estimating some of the edge times). \\n \\n Given this, we instead work out the ratio between the best travel time and the currentRoute travel time, \\n we multiply this ratio against the best travel time to give a better, more accurate estimation of the \\n currentRoute's travel time.\\n \\\"\\\"\\\"\\n if newRouteTime < bestTime:\\n # These are the predicted route times which are given directly from TraCI\\n bestTimeGivenByTraci = 0\\n newRouteTimeGivenByTraci = 0\\n\\n # These are the smoothed travel times which are generated through the vehicle's individual rerouting\\n # device\\n smoothedBestTime = 0\\n smoothedNewTime = 0\\n\\n # Times for the best route\\n for edge in routes['1_best'][1]:\\n bestTimeGivenByTraci += traci.edge.getTraveltime(edge)\\n smoothedBestTime += float(traci.vehicle.getParameter(veh, \\\"device.rerouting.edge:{}\\\".format(edge)))\\n\\n # Times for the new route\\n for edge in currentRoute:\\n newRouteTimeGivenByTraci += traci.edge.getTraveltime(edge)\\n smoothedNewTime += float(traci.vehicle.getParameter(veh, \\\"device.rerouting.edge:{}\\\".format(edge)))\\n\\n traciRatio = newRouteTimeGivenByTraci / bestTimeGivenByTraci\\n smoothedRatio = smoothedNewTime / smoothedBestTime\\n\\n \\\"\\\"\\\"\\n In extremely rare cases, TraCI can erroneously return an incorrect edge travel time which means\\n that the 'best' travel time may not actually be the best when taking these estimated travel time\\n measurements; this can result in ratios < 1.\\n \\\"\\\"\\\"\\n if traciRatio < 1 and smoothedRatio < 1:\\n bestRouteMoreThanNewRouteTime = True\\n\\n # Add the new time to the list so that it can be determined whether or not the existing times can\\n # exist given this new best time (with boundaries in mind)\\n routes['{}_best'.format(k + 1)] = (newRouteTime, currentRoute,)\\n\\n # All of the route and time pair combinations\\n tupleList = []\\n for key in routes:\\n timeRouteTuple = routes[key]\\n tupleList.append(timeRouteTuple)\\n\\n # Sort the tuples with the lowest time being at index 0, with the longest being at index k-1\\n sortedTuples = sorted(tupleList, key=lambda x: x[0])\\n\\n # Placing the contents of the sortedTuple into routes\\n counter = 0\\n for key in routes:\\n routes[key] = sortedTuples[counter]\\n counter += 1\\n\\n # Best time will now be in the first position\\n bestTime = routes['1_best'][0]\\n\\n # Delete any routes which don't conform to <= new best time *\\n for key in deepcopy(routes):\\n if routes[key][0] >= bestTime * KPATH_MAX_ALLOWED_TIME:\\n del routes[key]\\n\\n # Resetting k depending on how many elements are left after removal\\n k = len(routes)\\n else:\\n # This takes the most accurate ratio (which is deemed to be the ratio which is closest to 1)\\n traciRatio = min([traciRatio, smoothedRatio], key=lambda v: abs(v - 1))\\n # Work out the new, more accurate currentRoute travel time based on this ratio\\n newRouteTime = bestTime * traciRatio\\n\\n # New route's estimated time doesn't exceed bestTime*KPATH_MAX_ALLOWED_TIME of the optimal route time\\n if newRouteTime <= bestTime*KPATH_MAX_ALLOWED_TIME and not bestRouteMoreThanNewRouteTime:\\n k += 1\\n for edge in currentRoute:\\n if edge not in adjustedEdgeVehicle:\\n adjustedEdgeVehicle[edge] = edgeSpeedGlobal[edge]\\n edgesSet.update(currentRoute)\\n routes['{}_best'.format(k)] = (newRouteTime, currentRoute,)\\n else:\\n break\\n else:\\n timeOut += 1\\n # Time out limit exceeded\\n if timeOut == KPATH_TIMEOUT:\\n break\\n\\n # Selecting a random route\\n ranNum = random.randint(1, len(routes))\\n\\n routeChoice = routes['{}_best'.format(ranNum)]\\n\\n # Setting the additional (estimated) extra time in which the vehicle has taken due to reroutings\\n routeChoiceTimeTaken = routeChoice[0]\\n bestChoiceTimeTaken = routes['1_best'][0]\\n extraTime = routeChoiceTimeTaken - bestChoiceTimeTaken\\n cumulativeExtraTime[veh] += abs(extraTime)\\n\\n traci.vehicle.setRoute(veh, routeChoice[1])\\n\\n resetVehicleAdaptedTravelTime(veh, edgesSet)\\n\\n # These are the routes which were available to be selected\\n routeList = [x[1] for x in routes.values()]\\n\\n return routeList\",\n \"def find_best_cycle(road_map):\\n #Assume the best_cycle is the initial road map and calculate total distance \\n best_cycle = road_map\\n best_cycle_dist = compute_total_distance(road_map)\\n best_attempts = [best_cycle_dist]\\n # For each city in the road map\\n for i in range(len(road_map)):\\n for swaps in range(10000):\\n #A random number between 0 and total number of cities is generated.\\n number = int(len(road_map) * random.random())\\n # Create a test tuple where the first field in the tuple is the road map,\\n # with two cities swapped, and second field is total distance.\\n # The type of swap depends on whether the random number is odd or even.\\n # If even or if i is equal to number, the cities at index i and i+1 is swapped.\\n # If odd and i is not equal to number, the cities at index i and number are swapped.\\n # As a result, on each swap, there is\\n # 50% chance of either type of swap being selected.\\n if number % 2 == 1 and i != number:\\n test = swap_cities(best_cycle,i,number)\\n else:\\n test = swap_adjacent_cities(best_cycle,i)\\n # Compare the second field with current best cycle distance\\n # If current best cycle distance is greater, then set best cycle\\n # to the road map after swapping \\n if best_cycle_dist > test[1]:\\n best_cycle = test[0]\\n best_cycle_dist = test[1]\\n if best_attempts[len(best_attempts)-1] > best_cycle_dist:\\n best_attempts.append(best_cycle_dist)\\n return best_cycle, best_cycle_dist, best_attempts\",\n \"def calculate_next_move(self, visit):\\n self.depth += 1\\n new_boards = []\\n for vehicle_id in range(len(self.vehicles)):\\n vehicle = self.vehicles[vehicle_id]\\n state = self.get_board()\\n if vehicle.orientation == 0: #horizontal\\n if vehicle.x > 0: #left\\n if state[vehicle.y][vehicle.x-1] == \\\"..\\\":\\n self.vehicles[vehicle_id].x -=1\\n if not self.get_board().tostring() in visit:\\n if not self.get_board().all in new_boards:\\n new_board = deepcopy(self)\\n self.vehicles[vehicle_id].x += 1\\n new_board.parent = self\\n new_boards.append(new_board)\\n else:\\n self.vehicles[vehicle_id].x += 1\\n\\n if vehicle.x + vehicle.length <= (len(state)-1): #right\\n if state[vehicle.y][vehicle.x+vehicle.length] == \\\"..\\\":\\n self.vehicles[vehicle_id].x += 1\\n if not self.get_board().tostring() in visit:\\n if not self.get_board().all in new_boards:\\n new_board = deepcopy(self)\\n self.vehicles[vehicle_id].x -= 1\\n new_board.parent = self\\n new_boards.append(new_board)\\n else:\\n self.vehicles[vehicle_id].x -= 1\\n\\n else: #vertical\\n if vehicle.y - 1 >= 0: #up\\n if state[vehicle.y-1][vehicle.x] == \\\"..\\\":\\n self.vehicles[vehicle_id].y -= 1\\n if not self.get_board().tostring() in visit:\\n if not self.get_board().all in new_boards:\\n new_board = deepcopy(self)\\n self.vehicles[vehicle_id].y += 1\\n new_board.parent = self\\n new_boards.append(new_board)\\n else:\\n self.vehicles[vehicle_id].y += 1\\n\\n if vehicle.y + vehicle.length <= (len(state)-1):\\n if state[vehicle.y + vehicle.length][vehicle.x] == \\\"..\\\":#down\\n self.vehicles[vehicle_id].y += 1\\n if not self.get_board().tostring() in visit:\\n if not self.get_board().all in new_boards:\\n new_board = deepcopy(self)\\n self.vehicles[vehicle_id].y -= 1\\n new_board.parent = self\\n new_boards.append(new_board)\\n else:\\n self.vehicles[vehicle_id].y -= 1\\n self.depth -= 1\\n return new_boards\",\n \"def _get_vehicle(self, vehicle):\\n vehicle_bp = self.blueprint_lib.find(vehicle)\\n spawn_point = random.choice(self.world.get_map().get_spawn_points())\\n self.last_location = spawn_point.location\\n vehicle = None\\n for _ in range(10):\\n vehicle = self.world.try_spawn_actor(vehicle_bp, spawn_point) # this will return None if spawning failed\\n if vehicle:\\n break\\n if not vehicle:\\n raise(\\\"Spawning failed, perhaps there are too many actors already in world\\\")\\n \\n return vehicle\",\n \"def next_step(self, goal, traps=False): #TODO: test (maybe change to l1 dist?)\\n kyu = PriorityQueue()\\n kyu.put((0, self.player))\\n came_from = {self.player: None}\\n costs_agg = {self.player: 0}\\n\\n while not kyu.empty():\\n curr = kyu.get()[1]\\n if curr == goal: break\\n\\n for next in self.valid_neighbors(curr):\\n new_cost = costs_agg[curr] + (5 if traps and self.traps[next] else 1)\\n if next not in costs_agg.keys() or new_cost < costs_agg[next]:\\n costs_agg[next] = new_cost\\n kyu.put((new_cost + l2(next, goal), next))\\n came_from[next] = curr\\n \\n if goal in came_from.keys():\\n return came_from[goal]\\n else:\\n raise RuntimeWarning(\\\"no path between monster and player\\\")\\n return goal\",\n \"def getNextNodeUsingCellDiff(kGoalState):\\n \\n global fringe\\n global solutions\\n\\n \\n\\n\\n\\n minNode = None\\n minCost = 99999999999\\n minNodeIndex = -1\\n\\n \\n pnode = None\\n pcost = None\\n\\n if len(solutions)>0 and solutions[0] != None:\\n pnode = solutions[0];\\n pcost = getHValueForNode(pnode,kGoalState)\\n #print pnode, pcost\\n # raw_input()\\n \\n\\n\\n\\n for idx,node in enumerate(fringe):\\n #get the heu. function values\\n g_value = getHValueForNode(node,kGoalState)\\n \\n\\n if g_value < minCost:\\n minNode = node\\n minNodeIndex = idx\\n minCost = g_value\\n\\n\\n fringe.pop(minNodeIndex)\\n c = getHValueForNode(minNode,kGoalState)\\n if pnode != None:\\n if c > pcost:\\n minNode = None\\n \\n return minNode\",\n \"def get_dists_to_from_new_cust(\\n customer: Customer,\\n known_customers: List[Customer],\\n osr_api_key: str,\\n) -> Dict[Tuple[str, str], float]:\\n\\n # If there are no existing customers, just return a 0-distance dict for the\\n # single self-directed arc.\\n if not known_customers:\\n return {(customer.cust_id, customer.cust_id): 0.0}\\n\\n # Instantiate our client to pull the distance matrix.\\n osr_client = client.Client(key=osr_api_key)\\n\\n # Get the list of customer coordinates, along with their IDs.\\n # Note that they're in (lon, lat) order instead of (lat, lon).\\n cust_coords_w_id = [(known_cust.cust_id, (known_cust.lon, known_cust.lat)) for known_cust in known_customers]\\n\\n # Append the new customer.\\n cust_coords_w_id.append((customer.cust_id, (customer.lon, customer.lat)))\\n\\n # Note the number of total customers, along with the index of the new customer that we need distances for.\\n n = len(cust_coords_w_id)\\n new_cust_idx = n-1\\n\\n # Define the basic request we'll make to fetch the distance matrix.\\n request = {\\n 'locations': [cust_coords[1] for cust_coords in cust_coords_w_id],\\n 'profile': 'driving-car',\\n 'metrics': ['duration'],\\n }\\n\\n # First, get the distances FROM the new customer to all the existing customers\\n request['sources'] = [new_cust_idx]\\n response = osr_client.distance_matrix(**request)['durations']\\n logging.info(\\\"Distances *FROM* new customer retrieved\\\")\\n new_distances = {\\n (cust_coords_w_id[new_cust_idx][0], cust_coords_w_id[i][0]): response[0][i]\\n for i in range(n) # This also includes the distance from the new customer to itself\\n }\\n\\n # Next, get the distances TO the new customer from all the existing customers\\n request.pop('sources') # no longer want to specify a single source\\n request['destinations'] = [new_cust_idx] # but we do want to specify a destination\\n response = osr_client.distance_matrix(**request)['durations']\\n logging.info(\\\"Distances *TO* new customer retrieved\\\")\\n new_distances.update({\\n (cust_coords_w_id[i][0], cust_coords_w_id[new_cust_idx][0]): response[i][0]\\n for i in range(new_cust_idx) # don't include the dist to itself this time\\n })\\n \\n return new_distances\",\n \"def get_next_index(car_position):\\n next_index = False\\n\\n index_car_position = car_position[2]\\n next_index_car_position = index_car_position + 1\\n next_car_position = self.waypoints_list[\\n next_index_car_position]\\n\\n if next_car_position[1] == car_position[1]:\\n if car_position[1] < vehicle_posy < next_car_position[1]:\\n next_index = True\\n # rospy.logerr(\\\"check_point1\\\")\\n\\n elif next_car_position[0] == car_position[0]:\\n if car_position[0] < vehicle_posx < next_car_position[0]:\\n next_index = True\\n # rospy.logerr(\\\"check_point2\\\")\\n\\n else:\\n coeff1 = ((next_car_position[1] - car_position[1]) /\\n (next_car_position[0] - car_position[0]))\\n\\n coeff2 = -(1 / coeff1)\\n\\n b_low = car_position[1] - (coeff2 * car_position[0])\\n b_high = next_car_position[1] - (coeff2 * next_car_position[0])\\n\\n x_b_p = (self.pose_position.y - b_low) / coeff2\\n y_b_p = (coeff2 * self.pose_position.x) + b_low\\n\\n x_b_np = (self.pose_position.y - b_high) / coeff2\\n y_b_np = (coeff2 * self.pose_position.x) + b_high\\n\\n if x_b_p < vehicle_posx < x_b_np and \\\\\\n y_b_p < vehicle_posy < y_b_np:\\n next_index = True\\n\\n if next_index:\\n index_car_position = car_position[2] + 1\\n next_index_car_position = index_car_position + 1\\n next_car_position = self.waypoints_list[\\n next_index_car_position]\\n\\n return index_car_position\",\n \"def getNextNodeUsingTotalStepsToTravel(kGoalState):\\n \\n global fringe\\n global solutions\\n\\n\\n\\n minNode = None\\n minCost = 99999999999\\n minNodeIndex = -1\\n\\n \\n pnode = None\\n pcost = None\\n\\n if len(solutions)>0 and solutions[0] != None:\\n pnode = solutions[0];\\n pcost = getTotalStepsToReachGoalState(pnode,kGoalState)\\n # print pnode, pcost\\n # raw_input()\\n \\n\\n\\n\\n for idx,node in enumerate(fringe):\\n #get the heu. function values\\n g_value =getTotalStepsToReachGoalState(node,kGoalState)\\n \\n\\n if g_value < minCost:\\n minNode = node\\n minNodeIndex = idx\\n minCost = g_value\\n\\n\\n fringe.pop(minNodeIndex)\\n c = getTotalStepsToReachGoalState(minNode,kGoalState)\\n if pnode != None:\\n if c > pcost:\\n minNode = None\\n \\n return minNode\",\n \"def get_quickest_route_via(network, start,destination, vias):\\n # On récupère la liste des villes\\n list_city = network[1].keys()\\n \\n # On vérifie que toutes les villes existent\\n for via in vias:\\n if via not in list_city:\\n\\t return None\\n\\t \\n # On utilise Floyd pour parcourir les chemins les plus rapide de ville ne ville\\n roads = []\\n done = []\\n city_previous = start\\n for via in vias:\\n\\troad = get_shortest_route_floyd(network, city_previous, via) #done[:-1]) # dépend si on peut ou pas repasser par les villes déjà visité\\n\\tif road != None:\\n\\t roads.extend( road )\\n\\t done.append( via )\\n\\t city_previous = via\\n\\t \\n # On utilise Floyd pour finir le parcourt jusqu'à la ville de fin\\n road = get_shortest_route_floyd(network, city_previous,destination) #done[:-1]) # dépend si on peut ou pas repasser par les villes déjà visité\\n if road != None:\\n roads.extend( road )\\n\\t\\n # Si on trouve rien, on renvoie None\\n if roads == []:\\n return None\\n return roads\",\n \"def choose_destination(self, graph, current, unvisited):\\n if len(unvisited) == 1:\\n return unvisited[0]\\n scores = self.get_scores(graph, current, unvisited)\\n return self.choose_node(unvisited, scores)\",\n \"def find_best_cycle(road_map):\\n \\n best_cycle = road_map\\n best_dist = compute_total_distance(best_cycle)\\n i = 0\\n \\n try: \\n while i < 10000:\\n attempt_map = shift_cities(best_cycle)\\n rand_idx1 = random.randint(0, len(best_cycle)-1)\\n rand_idx2 = random.randint(0, len(best_cycle)-1)\\n (new_map, distance) = swap_cities(attempt_map, rand_idx1, rand_idx2)\\n if distance < best_dist:\\n best_dist = distance\\n best_cycle = new_map\\n i += 1\\n except Exception as e:\\n print('Error with find_best_cycle function: '+str(e))\\n \\n return best_cycle\",\n \"def getNextDest(self):\\n\\n if self.direction_forward:\\n if len(self.destinations)-1 == self.current_loc: #if Autobuz reaches rightmost destination, it also takes a break and changes directions\\n self.direction_forward = False #Autobuz changes direction\\n self.updateOmLocation()\\n return self.destinations[self.current_loc], (self.break_duration + self.trip_duration) #return destination reached and elapsed time\\n \\n else:\\n self.current_loc += 1\\n self.updateOmLocation()\\n return self.destinations[self.current_loc], self.trip_duration\\n \\n else:\\n if 0 == self.current_loc: #if Autobuz reaches leftmost destination, it also takes a break and changes directions\\n self.direction_forward = True #Autobuz changes direction\\n self.updateOmLocation()\\n return self.destinations[self.current_loc], (self.break_duration + self.trip_duration)\\n \\n else:\\n self.current_loc -= 1\\n self.updateOmLocation()\\n return self.destinations[self.current_loc], self.trip_duration\",\n \"def knearest_amongst_user_rated( self, restaurant_id, user_id, k = 7, reg = 3.0 ):\\n\\t\\tuser_rated = self.df[ self.df['user_id'] == user_id ]['business_id'].unique()\\n\\t\\treturn self.knearest( restaurant_id = restaurant_id, \\n\\t\\t\\t\\t\\t\\t\\t set_of_restaurants = user_rated, k = k, reg = reg )\",\n \"def local_optimum(self, tour: Tour):\\n better = tour\\n cnt = 0\\n while better is not None:\\n # if cnt % 20 == 0:\\n print(\\\"---------------------------------------------\\\\n The \\\", cnt, \\\"time.\\\")\\n print(\\\"Improved tour:\\\", list(better.iter_vertices()))\\n print(\\\"Improved cost:\\\", self.tour_cost(better))\\n cnt += 1\\n tour = better\\n better = self.improve(tour)\\n return tour\",\n \"def get_next(self,day,link,current_time,route): \\n if day not in self.data:\\n print('missing day')\\n return None\\n if link not in self.data[day]:\\n print([l for l in self.data[day]])\\n print('missing link')\\n return None\\n if route not in self.data[day][link]:\\n print('missing route')\\n return None\\n import numpy as np\\n try:\\n #efficent numpy look up.\\n index=[np.searchsorted(self.data[day][link][route][0:,0],current_time)]\\n except:\\n print('broken for this route')\\n return None\\n if index[0] < len(self.data[day][link][route]):\\n return self.data[day][link][route][index[0]]\\n else:\\n return None\",\n \"def FindNext():\\r\\n return _hiew.HiewGate_FindNext()\",\n \"def find_next(graph, strategy, mission, node, parent_node=None,\\n matrix=None):\\n debug('strategy =', strategy)\\n node_gt = graph.name2node[node]\\n nodes_gt = [n for n in node_gt.out_neighbours()]\\n nodes = [graph.vp['name'][n] for n in nodes_gt]\\n debug('nodes =', nodes)\\n if strategy == 'random':\\n if parent_node is not None and parent_node not in nodes:\\n nodes.append(parent_node)\\n return random.choice(nodes)\\n neighbor_targets = [n for n in nodes if n in mission.targets[0]]\\n if neighbor_targets:\\n debug('target in neighbors')\\n return neighbor_targets[0]\\n\\n nodes = [n for n in nodes if n not in mission.visited]\\n try:\\n candidates = {n: matrix[n, mission.targets[0][0]] for n in nodes}\\n except KeyError:\\n pdb.set_trace()\\n except TypeError, e:\\n print(e)\\n pdb.set_trace()\\n if not candidates:\\n chosen_node = None # abort search\\n else:\\n if strategy == 'title_stochastic' and random.random() <= 0.05:\\n chosen_node = random.choice(candidates.keys())\\n debug('randomly selecting node', chosen_node)\\n return chosen_node\\n chosen_node = max(candidates.iteritems(),\\n key=operator.itemgetter(1))[0]\\n debug('candidates are:')\\n for k, v in candidates.items():\\n debug(k, ':', v)\\n if chosen_node == parent_node:\\n debug('backtracking to node', parent_node)\\n return None\\n debug('going to ', chosen_node)\\n return chosen_node\",\n \"def opt_road(player, board, building_vertex):\\n player_buildings = board.get_player_settlements(player.player_id) + board.get_player_cities(player.player_id)\\n player_roads = board.get_player_roads(player.player_id)\\n accessible_vertices = sorted(set(player_buildings+ [v for pair in player_roads for v in pair]), \\\\\\n key = lambda v: manhattan_distance(v,building_vertex,board))\\n if building_vertex in accessible_vertices:\\n print(\\\"Error: Building vertex already accessible, do not need road.\\\")\\n return None, None\\n for v in accessible_vertices:\\n neighbor_vertices = []\\n x,y = board.get_vertex_location(v)\\n for dx, dy in [[0,1],[0,-1],[1,0],[-1,0]]:\\n xx = x + dx\\n yy = y + dy\\n if board.get_vertex_number(xx,yy) in range(board.max_vertex+1):\\n neighbor_vertices.append(board.get_vertex_number(xx,yy))\\n neighbor_vertices = sorted(neighbor_vertices, key = lambda v: manhattan_distance(v,building_vertex,board))\\n for n in neighbor_vertices:\\n if board.if_can_build_road(v, n, player.player_id):\\n v_t = list(board.get_vertex_location(v))\\n n_t = list(board.get_vertex_location(n))\\n return v_t, n_t\\n print(\\\"need to implement default behavior\\\")\\n return None,None\",\n \"def nearest(node):\\n count = 0\\n distance = 100000\\n while count != node_count[0]:\\n city = d_list[node.value - 1]\\n if city != []:\\n if city[0][1] < distance:\\n distance = city[0][1]\\n new_city = city[0][0]\\n closest_city = node.value\\n node = node.left\\n count = count + 1\\n return (closest_city, new_city, distance)\",\n \"def greedy_path():\\n itinerary = []\\n cities = all_cities(data_set)\\n starting_city = randomize_city_start(cities.keys()) # start from a random city\\n # print \\\"starting_city: %s\\\" % starting_city\\n cities_visited = {}\\n \\n # iterate through all cities\\n count = 1\\n while True:\\n possible_routes = []\\n #distance = []\\n # print \\\"starting_city: %s\\\" % starting_city\\n for path in data_set:\\n # we only start with city that we have assigned in starting_city\\n if starting_city in path['city_start']:\\n # we don't go to cities we have visited\\n if path['city_end'] in cities_visited:\\n continue\\n else:\\n # print \\\"path: \\\", path\\n possible_routes.append(path) # add the city if not in the list\\n \\n if not possible_routes:\\n break\\n # append this to itinerary\\n route = get_shortest_route(possible_routes)\\n count += 1\\n itinerary.append(route)\\n # add this city to visited_cities list\\n cities_visited[route[0]] = count\\n starting_city = route[1]\\n \\n return itinerary\",\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 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 acceptance(current, candidate,fitness):\\n cost_current = fitness(current)\\n cost_candidate = fitness(candidate)\\n if cost_current < cost_candidate: # Minimization\\n return current\\n else:\\n return candidate\",\n \"def road_next(self, vehicle, on_arrive, time):\\n events = []\\n edge = vehicle.current\\n if edge is not None:\\n # leave previous edge\\n edge['occupancy'] -= self.roads.vehicle_size\\n if edge['occupancy'] < 0:\\n raise Exception('occupancy should be positive')\\n vehicle.route.pop(0)\\n self.data['road_capacities'][edge['id']].append((float(edge['occupancy']), float(time)))\\n\\n # compute next leg\\n leg = self.road_travel(vehicle.route, vehicle.type)\\n\\n # random accidents\\n if random.random() < config.BASE_ACCIDENT_PROB:\\n # sort edges by occupancy\\n edges = [(e[:3], e[-1]['occupancy'])\\n for e in self.roads.network.edges(keys=True, data=True)\\n if e[-1]['occupancy'] > 0]\\n if len(edges) > 0:\\n edges, probs = zip(*edges)\\n edge_idxs = range(len(edges))\\n probs = probs/np.sum(probs)\\n edge_idx = np.random.choice(edge_idxs, 1, p=probs)[0]\\n edge = edges[edge_idx]\\n self.roads.network.edges[edge]['accident'] = True\\n logger.debug('Accident occurred at edge: {}'.format(edge))\\n\\n # Accident cleared up event\\n clear_time = random.randint(*config.ACCIDENT_CLEAR_TIME)\\n events.append((time+clear_time, partial(self.clear_accident, edge)))\\n\\n # arrived\\n if leg is None:\\n return events + on_arrive(time)\\n\\n # TODO replanning can occur here too,\\n # e.g. if travel_time exceeds expected travel time\\n leg, edge, travel_time = leg\\n\\n # enter edge\\n edge['occupancy'] += self.roads.vehicle_size\\n if edge['occupancy'] <= 0:\\n raise Exception('adding occupant shouldnt make it 0')\\n self.data['road_capacities'][edge['id']].append((float(edge['occupancy']), float(time)))\\n\\n vehicle.current = edge\\n\\n # cast to avoid errors with serializing numpy types\\n if self.save_history and time >= self.history_window[0] and time <= self.history_window[1]:\\n self.history[vehicle.id].append((float(time), float(travel_time), leg))\\n\\n # return next event\\n # TODO this assumes agents don't stop at\\n # lights/intersections, so should add in some time,\\n # but how much?\\n # or will it not affect the model much?\\n return events + [(travel_time, partial(self.road_next, vehicle, on_arrive))]\",\n \"def goto(vehicle, dNorth, dEast):\\n goto_function = vehicle.simple_goto # can be changed\\n currentLocation = vehicle.location.global_relative_frame\\n targetLocation = get_location_metres(currentLocation, dNorth, dEast)\\n targetDistance = get_distance_metres(currentLocation, targetLocation)\\n goto_function(targetLocation)\\n\\n #Stop action if we are no longer in guided mode.\\n while vehicle.mode.name == \\\"GUIDED\\\": \\n remainingDistance = get_distance_metres(vehicle.location.global_relative_frame, targetLocation)\\n #print \\\"Distance to target: \\\", remainingDistance\\n if remainingDistance <= shared.WP_RADIUS: #Just below target, in case of undershoot.\\n #print \\\"Reached target\\\"\\n break;\\n\\n time.sleep(0.5)\",\n \"def heuristic(current, goal):\\r\\n distance = getDistance(current, goal)\\r\\n return distance\",\n \"def cust_loc(sol, cust):\\r\\n cust_ind = [] # [route_loc, cust_loc]\\r\\n for i, rt in enumerate(sol):\\r\\n if cust in rt:\\r\\n cust_ind.append(i)\\r\\n cust_ind.append(rt.index(cust))\\r\\n return cust_ind\\r\\n\\r\\n print('Costomer not in the solution: ', cust)\",\n \"def get_next_node(node_destinatari,node_enviant):\\n if node_list.index(node_destinatari)>node_list.index(node_enviant):\\n #sentit=\\\"up\\\"\\n node_anterior=node_list[node_list.index(id)-1]\\n node_seguent=node_list[node_list.index(id)-2]\\n if node_list.index(id)-3 < len(node_list):\\n node_seguent2=node_list[node_list.index(id)-3]\\n else:\\n node_seguent2=node_seguent\\n else:\\n return(id,id,id)\\n print(\\\"Get_next_node \\\",node_destinatari,node_enviant,\\\" result \\\",node_anterior,node_seguent,node_seguent2)\\n return(node_anterior,node_seguent,node_seguent2)\",\n \"def getNearestPassenger(driver, passengers):\\n driver = driver.reshape((1, 2))\\n assert (driver.shape == (1, 2))\\n assert (passengers.shape[1] == 5)\\n\\n mask = passengers[:, -1] == 1\\n tmp = passengers[mask]\\n\\n dis = np.linalg.norm(tmp[:, 0:2].copy() - driver)\\n mini = np.argmin(dis)\\n tmp[mini, -1] = 0\\n passengers[mask] = tmp\\n return tmp[mini, 0:4], passengers, tmp.shape[0] - 1\",\n \"def _compute_connection(current_waypoint, next_waypoint, threshold=35):\\n n = next_waypoint.transform.rotation.yaw\\n n = n % 360.0\\n\\n c = current_waypoint.transform.rotation.yaw\\n c = c % 360.0\\n\\n diff_angle = (n - c) % 180.0\\n if diff_angle < threshold or diff_angle > (180 - threshold):\\n return RoadOption.STRAIGHT\\n elif diff_angle > 90.0:\\n return RoadOption.LEFT\\n else:\\n return RoadOption.RIGHT\",\n \"def get_distance(highway_now: list, car_index: int) -> int:\\n\\n distance = 0\\n cells = highway_now[car_index + 1 :]\\n for cell in range(len(cells)): # May need a better name for this\\n if cells[cell] != -1: # If the cell is not empty then\\n return distance # we have the distance we wanted\\n distance += 1\\n # Here if the car is near the end of the highway\\n return distance + get_distance(highway_now, -1)\",\n \"def dispersy_get_walk_candidate(self):\\n now = time()\\n result = None\\n method = self._scenario_script.candidate_strategy\\n #walk_type=\\\"with_restarts\\\"\\n\\n def get_score(candidate):\\n try:\\n peer = self._scenario_script.get_peer_from_candidate(candidate)\\n except:\\n logger.warning(\\\"fault in the database: unable to get peer from candidate\\\")\\n return 0.0\\n member = self._dispersy.get_member(peer.public_key)\\n return self._scores.get(member.database_id, 0.0)\\n \\n def prob_choice(bias):\\n randNum = pythonrandlib.random() # in [0,1)\\n if sum(bias)>0:\\n sum_mass = 0.0\\n result = 0\\n norm_bias=[ x*(1/sum(bias)) for x in bias]\\n for mass in norm_bias:\\n sum_mass += mass\\n if randNum <= sum_mass:\\n return result\\n result+=1\\n else:\\n result = int(randNum*len(bias))\\n return result\\n # use the default Dispersy strategy if neither enable_probabilistic_candidate nor\\n # enable_deterministic_candidate is chosen\\n if method == \\\"dispersy\\\":\\n result = self.dimitra_dispersy_get_walk_candidate()\\n\\n # introduction based on the locally compute scores\\n\\n if self._scenario_script.enable_following:\\n #if walk_type=\\\"with_restarts\\\":\\n logger.info(\\\"start of the RW-following\\\")\\n \\n # with teleportation probability 0.2\\n if pythonrandlib.random() < 0.2:\\n self.log(\\\"walk-teleport\\\")\\n logger.info(\\\"teleportation phase with probability 0.2\\\")\\n pass\\n\\n\\n else: \\n logger.info(\\\"RW on process: selection of the next node\\\")\\n candidates = [(candidate.last_intro, candidate)\\n for candidate\\n in self._candidates.itervalues()]\\n # if candidate.is_eligible_for_walk(now, method=method)]\\n if candidates:\\n candidates.sort()\\n result = candidates[-1][1]\\n # this must be enabled for churn\\n # if not result.is_eligible_for_walk(now, method=\\\"dispersy\\\"):\\n # result = None\\n\\n #logger.info(\\\"node %d chooses peer_number:%d\\\", self._scenario_script.peer_number, result.peer_number)\\n #if walk_type=\\\"early_teminated\\\":\\n # ttl<-0\\n # # with teleportation probability 0.2\\n # if ttl>7:\\n # method = \\\"probabilistic\\\"\\n\\n # else:\\n # candidates = [(candidate.last_intro, candidate) for candidate in self._candidates.itervalues() if candidate.is_eligible_for_walk(now)]\\n # if candidates:\\n # ttl<-ttl+1\\n # candidates.sort()\\n # yield candidates[-1]\\n\\n #if method in (\\\"probabilistic\\\", \\\"deterministic\\\"):\\n\\n #[(SCORE, CANDIDATE), (SCORE, CANDIDATE), ...]\\n # candidates = [(get_score(candidate), candidate)\\n # for candidate\\n # in self._candidates.itervalues()\\n # if candidate.is_eligible_for_walk(now, method=method)]\\n # if candidates:\\n #### Preobabilistic\\n # assume sum of bias is 1\\n\\n # if method==\\\"probabilistic\\\":\\n \\n # candidate_index = prob_choice([score for score, candidate in candidates])\\n # result = candidates[candidate_index][1]\\n\\n # if method==\\\"deterministic\\\":\\n # yield candidates in best to worst order\\n # sorted(candidates, reverse=True)\\n # result = candidates[0][1]\\n\\n if result is None: \\n logger.info(\\\"RW failed: back to the bootstrap nodes \\\")\\n # FALLBACK TO BOOTSTRAP NODES\\n #bootstrap_candidates = list(self._iter_bootstrap(once=True))\\n #pythonrandlib.shuffle(bootstrap_candidates)\\n #for candidate in bootstrap_candidates:\\n # if candidate:\\n # result = candidate\\n # break\\n try:\\n list_member = [self._dispersy.get_member_from_database_id(member_id) for member_id, in self._database.execute(u\\\"SELECT member FROM book\\\")]\\n list_peer = [self._scenario_script.get_peer_from_public_key(member.public_key) for member in list_member]\\n except RuntimeError:\\n return None\\n \\n candidates = [WalkCandidate(peer.lan_address, False, peer.lan_address, peer.wan_address, u\\\"unknown\\\")\\n for peer\\n in list_peer]\\n candidates = [(get_score(candidate), candidate) for candidate in candidates] \\n if candidates:\\n candidate_index = prob_choice([score for score, candidate in candidates])\\n result = candidates[candidate_index][1]\\n #can=[self._scenario_script.get_peer_from_candidate(candidate).peer_number for candidate in candidates]\\n #list_cand= intersect(ver,can)\\n # list_peer.sort(key=lambda peer: peer.peer_number)\\n #if list_peer:\\n #index=randint(0,(len(list_cand)-1))\\n #member = list_cand[index]\\n \\n # if self._scenario_script.peer_number in (0, 499):\\n # peer = list_peer[0] \\n # else:\\n # peer = list_peer[-1]\\n \\n #candidate = candidates[index_in_can]\\n #candidate=\\n #peer_tuple=self._scenario_script.get_peer_from_public_key(member.public_key)\\n # result = WalkCandidate(peer.lan_address, False, peer.lan_address,peer.wan_address,u\\\"unknown\\\")\\n #self.log(\\\"available-candidates\\\", \\n # verified=[str(candidate) for candidate in self.dispersy_yield_verified_candidates()], \\n # unverified=[str(candidate) for candidate in self.dispersy_yield_candidates()])\\n\\n if result is None:\\n self.log(\\\"walk-candidate\\\", strategy=method, lan_address=None, wan_address=None)\\n logger.warning(\\\"no candidates or bootstrap candidates available\\\")\\n\\n else:\\n self.log(\\\"walk-candidate\\\", strategy=method, lan_address=result.lan_address, wan_address=result.wan_address)\\n\\n return result\",\n \"def findNextMove(curHVal):\\n minHCalc = curHVal; #Initializing to curHVal\\n minNewPosition = (0,0); #Initializing it\\n\\n tempBoardPositions = [x for x in positions]\\n \\n for move in findPlacesToMove():\\n #Move number to blank\\n tempBoardPositions[curBlank[0]][curBlank[1]] = tempBoardPositions[move[0]][move[1]];\\n #Move blank to new move position\\n tempBoardPositions[move[0]][move[1]] = 0;\\n \\n hVal = heuristicValueOfPosition(tempBoardPositions);\\n if(hVal < minHCalc):\\n minHCalc = hVal;\\n minNewPosition = move;\\n \\n #Resetting board to what it was before this move\\n tempBoardPositions[move[0]][move[1]] = tempBoardPositions[curBlank[0]][curBlank[1]]\\n #tempBoardPositions[curBlank[0]][curBlank[1]] = 0;\\n\\n print(\\\"After calc -- {}\\\".format(positions))\\n \\n if minHCalc < curHVal:\\n return (minNewPosition, minHCalc)\\n else:\\n return -1; #That we have reached local minima\",\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 pickBestCandidateToMergeWith(segmentToMerge,neighbours,mergedSegments,updatedSpeed,weights):\\n criteronScores = [\\n profileSim(segmentToMerge,neighbours,updatedSpeed),\\n directtion(segmentToMerge,neighbours,mergedSegments),\\n shareNoEdges(segmentToMerge,neighbours,mergedSegments)\\n ]\\n return neighbours[sum(criteronScores*weights).argmin()]\",\n \"def shortest_flight(g):\\n min_distance = sys.maxsize\\n min_destination = None\\n min_key = None\\n \\n for key in g.city_dict:\\n for flight in g.city_dict[key].get_flights_out():\\n if(flight[1] < min_distance):\\n min_key = key\\n min_destination = flight[0]\\n min_distance = flight[1]\\n return g.city_dict[min_key].get_name(), min_destination, min_distance\",\n \"def heuristic(current, goal):\\r\\n\\r\\n return Vector2.fromCell(current).distanceTo(Vector2.fromCell(goal))\",\n \"def related_movie_offset(movie_id, customer_id):\\n offset = 0.0\\n if movie_id in CACHE_RELATED_MOVIES:\\n for other_mov, weight in CACHE_RELATED_MOVIES[movie_id].items():\\n if customer_id in CACHE_ANSWERS[other_mov]:\\n offset += weight * (netflix_predict(other_mov, customer_id) - CACHE_ANSWERS[other_mov][customer_id])\\n return -1 * offset\",\n \"def succ_car_other_lane(self):\\n other_lane = self.other_lane()\\n\\n for i in range(self.road.N):\\n if self.road.cells[other_lane][(self.x - (i + 1)) % (self.road.N-1)] != -1:\\n return self.road.cars[self.road.cells[other_lane][(self.x - (i + 1)) % (self.road.N-1)]]\",\n \"def plan(cur_pos: Node, goal_pos: Node, cur_heading: float, new_obst_segments: [ObstacleSegment]) \\\\\\n -> (NavMode, [Node]):\\n global d_reach, v_followed, v_diff, d_followed_rel, obst_id_to_follow, bf_waypoint\\n # find updated obstacle with obst_id_to_follow\\n obst_to_follow = find_obst(obst_id_to_follow, new_obst_segments)\\n\\n # check if we lost the obstacle\\n if obst_to_follow is None:\\n logger.info(\\\"BF: Lost obstacle segment; End of Routine\\\")\\n return NavMode.MTG, None\\n else:\\n # update BF Waypoint\\n bf_waypoint.update(obst_to_follow)\\n\\n # Calculate d_reach, d_followed, v_diff, d_followed_rel\\n v_diff = bf_waypoint.get_pos_change()\\n d_reach = goal_pos.dist_2d(bf_waypoint.cur_pos)\\n assert v_followed is not None and v_diff is not None\\n\\n v_followed_rel = v_followed + v_diff\\n d_followed_rel = v_followed_rel.dist_2d(goal_pos)\\n\\n # if d_reach < d_followed_rel\\n if d_followed_rel - d_reach > config_.D_TOL:\\n # switch to MTG\\n logger.info(\\\"BF: path length decreased by %.2f below original minimum; End of Routine\\\"\\n % (d_followed_rel - d_reach))\\n return NavMode.MTG, None\\n else:\\n # choose new BF waypoint\\n bf_waypoint = find_new_bf_waypoint(obst_to_follow, cur_pos, None)\\n if bf_waypoint is None:\\n return NavMode.MTG, None\\n\\n # generate path to bfWaypoint\\n path = [bf_waypoint.cur_pos, goal_pos]\\n\\n # update v_followed\\n v_followed = v_followed_rel\\n\\n return NavMode.BF, path\",\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 _choose_algorithm(vehicle, xbee, neighbors):\\n if shared.AGENT_CHARACTER == 'square':\\n return mas.SquareRoute(vehicle, xbee)\\n \\n elif shared.AGENT_CHARACTER == 'passive':\\n return mas.PassiveLeader(vehicle, xbee)\\n \\n elif shared.CURRENT_ALGORITHM == 'Vicsek':\\n return mas.Vicsek(vehicle, xbee, neighbors)\\n \\n elif shared.CURRENT_ALGORITHM == 'MPC':\\n return mas.Decentralized(vehicle, xbee, neighbors)\",\n \"def firstNeighbor(v):\\n for u in ranks:\\n if u in matched or not self.adjacent(u, v):\\n continue\\n\\n return u\",\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 heuristic_takeDomination(board, player):\\n\\n boardArray = board.get_board()\\n boardSize = board.get_board_size()\\n\\n otherPlayer = board._WHITE if player is board._BLACK else board._BLACK\\n\\n score = (board.getCurrentDomination(player) - board.getInitialDomination(player)) * 100\\n cst = 30\\n\\n for corner in board.get_corner():\\n if corner is player:\\n score += score\\n else:\\n score -= score\\n\\n\\n\\n return score\",\n \"def nearest_neighbour_heuristic(self, city_count):\\n return 1.0 / (500.0 * city_count)\",\n \"def Neighbors(vendor):\\n neighbors = {\\\"cisco\\\" : \\\"\\\", \\\"juniper\\\" : \\\"\\\", \\\"vyatta\\\" : \\\"\\\" }\\n cisco_neighbors = {}\\n juniper_neighbors = {}\\n vyatta_neighbors = {}\\n while True:\\n print \\\"***\\\\t\\\\t%s NEIGHBORS***\\\" % (vendor)\\n n = raw_input(\\\"\\\\t\\\\tNeighbor information (Press any key to continue. Press 'q' to quit): \\\")\\n if n is not 'q':\\n neighbor_id = raw_input(\\\"\\\\t\\\\tNeighbor ID (eg. x.x.x.x): \\\")\\n neighbor_as = raw_input(\\\"\\\\t\\\\tNeighbor AS: \\\")\\n if vendor == \\\"cisco\\\":\\n cisco_neighbors[neighbor_id] = neighbor_as\\n neighbors[vendor] = cisco_neighbors\\n elif vendor == \\\"juniper\\\":\\n juniper_neighbors[neighbor_id] = neighbor_as\\n neighbors[vendor] = juniper_neighbors\\n else:\\n vyatta_neighbors[neighbor_id] = neighbor_as\\n neighbors[vendor] = vyatta_neighbors\\n else:\\n break\\n return neighbors\",\n \"def _get_closest(self, x, y, clients):\\n target = min(\\n clients,\\n key=lambda c: math.hypot(c.x - x, c.y - y),\\n default=self.clients.current_client,\\n )\\n return target\",\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 nearest_neighbor(FILE_NAME):\\n time_0 = DEFAULT_TIMER()\\n list_of_cities = read_in_file(FILE_NAME)\\n best_opt_distance = sys.maxsize\\n best_sol_of_cities = []\\n\\n for city in list_of_cities: #iterate through all cities in the list\\n for resetCity in list_of_cities: #reset them all to not visited\\n resetCity[3] = False\\n sol_of_cities = [] #set our current solution to empty\\n opt_distance = 0 #reset our current optimal solution\\n nearest_dist = sys.maxsize #nearest distance is huge\\n nearest_city = 0\\n first_city = city #the first city visited is the next city in our iteration\\n first_city[3] = True\\n sol_of_cities.append(first_city[0])\\n\\n city_1 = first_city\\n\\n while len(sol_of_cities) < len(list_of_cities): #check the current city to\\n #find the closest city in the\\n #list of cities not visited\\n nearest_dist = sys.maxsize\\n for city_2 in list_of_cities:\\n #if the two cities are not the same and have not visited the second city\\n if city_1[0] != city_2[0] and city_2[3] != True:\\n dx = city_1[1] - city_2[1]\\n dy = city_1[2] - city_2[2]\\n dist_to = int(round(math.sqrt((dx*dx) + (dy*dy))))\\n #update nearest_city if the new distance is less than the current nearest distance\\n if dist_to < nearest_dist:\\n nearest_dist = dist_to\\n nearest_city = city_2\\n#add the city only if we haven't already visited it. Had a wierd bug need to investigate this further\\n if nearest_city[3] != True: \\n sol_of_cities.append(nearest_city[0])\\n opt_distance += nearest_dist\\n nearest_city[3] = True\\n city_1 = nearest_city\\n #quit if our distance is larger than our best solution found\\n if(opt_distance > best_opt_distance):\\n #print(\\\"quit this search\\\") #comment out, see skipped searches\\n break\\n#add the distance from the last city we visited back to the first city to make a tour\\n dx = nearest_city[1] - first_city[1]\\n dy = nearest_city[2] - first_city[2]\\n opt_distance += int(round(math.sqrt((dx*dx) + (dy*dy))))\\n#if our current solution is better than the previous solution replace it, then start over until we've checked all cities\\n if best_opt_distance > opt_distance:\\n best_opt_distance = opt_distance\\n best_sol_of_cities = sol_of_cities\\n #print(best_sol_of_cities) #can remove later for testing now\\n #print(best_opt_distance) #same as above\\n \\n write_to_file(best_sol_of_cities, best_opt_distance, FILE_NAME)\\n time_1 = DEFAULT_TIMER()\\n print(\\\"Time taken: \\\", (time_1 - time_0))\",\n \"def evaluate_distance(self):\\n\\n fitness = 0\\n routes = split_to_routes(self)\\n\\n for route in routes:\\n route = [home] + route + [home]\\n for i in range(1,len(route)):\\n # Calculates full distance, including from last city\\n # to first, to terminate the trip\\n pos_from = route[i - 1]\\n pos_to = route[i]\\n distance = dm[pos_from][pos_to]\\n fitness += distance\\n\\n return int(fitness)\",\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 greedy_initial(self):\\r\\n sol = [] # [[0;2;5;0;4;6;0],[],...]\\r\\n sol_veh_type = [] # corresponding vehicle type for the solution\\r\\n route_way_time = []\\r\\n\\r\\n to_vist = [i+1 for i in range(store_num - 1)] # [1,5,8,...]\\r\\n itr = 0\\r\\n\\r\\n while len(to_vist) > 0 and itr < 500:\\r\\n itr += 1\\r\\n\\r\\n if itr <= small_veh_cnt:\\r\\n vehicle_type0 = 2\\r\\n elif itr <= small_veh_cnt + medium_veh_cnt:\\r\\n vehicle_type0 = 3\\r\\n else:\\r\\n vehicle_type0 = 5\\r\\n\\r\\n sol_veh_type.append(vehicle_type0)\\r\\n\\r\\n used_res = [0, 0, 0, 0] # used volume, and travel time of the vehicle, leave time, travel distance\\r\\n veh_rout = [0]\\r\\n\\r\\n # print '\\\\nA new vehicle will be used.'\\r\\n way_time = 0 # travel time of coming to the store + wait time at the store + operation time at this store\\r\\n while True:\\r\\n curr_cust = veh_rout[-1]\\r\\n\\r\\n next_one, way_time = self.time_nn(way_time, curr_cust, to_vist, used_res, len(veh_rout), vehicle_type0)\\r\\n next_cust, next_start = next_one[0], next_one[1]\\r\\n # print('next start', next_cust, next_start)\\r\\n if next_cust == 0: # next visiting customer is depot\\r\\n # print 'Get back to the depot, and ready for a new round.'\\r\\n veh_rout.append(next_cust)\\r\\n break\\r\\n\\r\\n else: # next visiting customer is a store\\r\\n used_res[0] += (num_demd[next_cust][0] * bskt_vol + num_demd[next_cust][1] * trsf_vol + (num_demd[next_cust][2] + \\\\\\r\\n num_demd[next_cust][3]) * milk_vol + num_demd[next_cust][4] * paper_bskt)\\r\\n used_res[2] = (next_start + oprt_t)\\r\\n used_res[3] += dist_mat[curr_cust, next_cust]\\r\\n\\r\\n\\r\\n veh_rout.append(next_cust)\\r\\n # print 'Vehicle used resource: ', used_res\\r\\n to_vist.remove(next_cust)\\r\\n\\r\\n sol.append(veh_rout)\\r\\n route_way_time.append(way_time)\\r\\n\\r\\n # print 'Last point 0 earliest leave time: ', int(used_res[-1]) / 60, ':', int(used_res[-1]) % 60\\r\\n # print 'Route %s is: ' % itr, veh_rout\\r\\n print('*'*10, 'Iteration:', itr, '*'*10)\\r\\n\\r\\n\\r\\n if len(to_vist) > 0:\\r\\n print('number of stores remained: ', len(to_vist))\\r\\n\\r\\n return sol, sol_veh_type, route_way_time\",\n \"def change_way(coins, opponentLocation, player_location):\\n global best_weight, best_path\\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(5, coins, player_location, dists_matrix)\\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 best_weight = float(\\\"inf\\\")\\n best_path = []\\n api.debug(coins_to_search)\\n exhaustive(coins_to_search, player_location, [], 0, dist_matrix)\\n meta_route = [player_location] + best_path\\n api.debug(meta_route)\\n route = u.location_list_to_route(meta_route, route_matrix)\\n \\n return coins_to_search, meta_route, route, dist_matrix[player_location][meta_route[1]]\",\n \"def getBoarderGoal(self, gameState):\\n boards = self.boarders\\n myPos = self.getCurrentObservation().getAgentState(self.index).getPosition()\\n if len(boards) > 0:\\n dis = 9999\\n nearestBoarder = boards[0]\\n for b in boards:\\n temp = self.getMazeDistance(myPos, b)\\n if temp < dis:\\n dis = temp\\n nearestBoarder = b\\n return nearestBoarder, dis\\n else:\\n return None, None\",\n \"def pred_car_other_lane(self):\\n other_lane = self.other_lane()\\n\\n for i in range(self.road.N):\\n if self.road.cells[other_lane][(self.x + i + 1) % (self.road.N-1)] != -1:\\n return self.road.cars[self.road.cells[other_lane][(self.x + i + 1) % (self.road.N-1)]]\",\n \"def earliest_arrival(jump_distance, stones):\\n #jump_distance of 3 means they skip 2 stones and land on 3rd\\n stone = ''\\n #based on jump_distance, what are all the stone nums within that distance\\n #when jump_distance is 5, can jujp to stones[4]\\n \\n stone = min(stones[:(jump_distance - 1)]) #stone = 2\\n\\n t = max(0, stone) #t = 2\\n print(f't starts at = {t}')\\n i = stones.index(stone) # i = 1\\n print(f'i starts at = {i}') \\n #as long as \\n while i + jump_distance <= len(stones) - 1: # 3 + 5 <= 7\\n print(f'i + jump_distance = {i + jump_distance}')\\n\\n stone = min(stones[(i + 1):(i + jump_distance)]) #stone = 3\\n print(f'stone: {stone}')\\n if t < stone: \\n t = stone #reassign to 3\\n \\n i = stones.index(stone) # i = 2\\n print(f'i = {i}') \\n stone = min(stones[(i + 1):(i + jump_distance)]) #stone \\n t = max(t, stone)\\n print(f'end of while loop: t = {t}') \\n \\n return t\\n #what's the lowest num within that jump_distance \\n #go to that stone, then look at next stones in new jump_distance\\n #t becomes whatever stone we jumped to\\n #if the next stone we jump to is a higher value, reassign t\\n #get length of list of stones so we don't go past length\\n #var assigned to len(list) and compare to index we're at \\n #if index we're jumping to is higher than len of list, then we're done\\n #control for indexerror with while loop?\\n # \",\n \"def dimitra_dispersy_get_walk_candidate(self):\\n # 13/02/12 Boudewijn: normal peers can not be visited multiple times within 30 seconds,\\n # bootstrap peers can not be visited multiple times within 55 seconds. this is handled by\\n # the Candidate.is_eligible_for_walk(...) method\\n\\n assert all(not sock_address in self._candidates for sock_address in self._dispersy._bootstrap_candidates.iterkeys()), \\\"none of the bootstrap candidates may be in self._candidates\\\"\\n\\n from sys import maxint\\n\\n now = time()\\n categories = [(maxint, None), (maxint, None), (maxint, None)]\\n category_sizes = [0, 0, 0]\\n\\n for candidate in self._candidates.itervalues():\\n if candidate.is_eligible_for_walk(now):\\n category = candidate.get_category(now)\\n if category == u\\\"walk\\\":\\n categories[0] = min(categories[0], (candidate.last_walk, candidate))\\n category_sizes[0] += 1\\n elif category == u\\\"stumble\\\":\\n categories[1] = min(categories[1], (candidate.last_stumble, candidate))\\n category_sizes[1] += 1\\n elif category == u\\\"intro\\\":\\n categories[2] = min(categories[2], (candidate.last_intro, candidate))\\n category_sizes[2] += 1\\n\\n walk, stumble, intro = [candidate for _, candidate in categories]\\n while walk or stumble or intro:\\n r = pythonrandlib.random()\\n\\n # 13/02/12 Boudewijn: we decrease the 1% chance to contact a bootstrap peer to .5%\\n if r <= .4975: # ~50%\\n if walk:\\n logger.debug(\\\"returning [%2d:%2d:%2d walk ] %s\\\", category_sizes[0] , category_sizes[1], category_sizes[2], walk)\\n return walk\\n\\n elif r <= .995: # ~50%\\n if stumble or intro:\\n while True:\\n if pythonrandlib.random() <= .5:\\n if stumble:\\n logger.debug(\\\"returning [%2d:%2d:%2d stumble] %s\\\", category_sizes[0] , category_sizes[1], category_sizes[2], stumble)\\n return stumble\\n\\n else:\\n if intro:\\n logger.debug(\\\"returning [%2d:%2d:%2d intro ] %s\\\", category_sizes[0] , category_sizes[1], category_sizes[2], intro)\\n return intro\\n\\n # else: # ~.5%\\n # candidate = self._bootstrap_candidates.next()\\n # if candidate:\\n # logger.debug(\\\"returning [%2d:%2d:%2d bootstr] %s\\\", category_sizes[0] , category_sizes[1], category_sizes[2], candidate)\\n # return candidate\\n\\n bootstrap_candidates = list(self._iter_bootstrap(once=True))\\n pythonrandlib.shuffle(bootstrap_candidates)\\n for candidate in bootstrap_candidates:\\n if candidate:\\n logger.debug(\\\"returning [%2d:%2d:%2d bootstr] %s\\\", category_sizes[0] , category_sizes[1], category_sizes[2], candidate)\\n \\n logger.debug(\\\"no candidates or bootstrap candidates available\\\")\\n return None\",\n \"def search_next_win(self, player):\\n for i, j, k in self.winning_cases:\\n if self.game_board[i] == player and \\\\\\n self.game_board[j] == player and \\\\\\n self.game_board[k] == ' ':\\n return k\\n elif self.game_board[j] == player and \\\\\\n self.game_board[k] == player and \\\\\\n self.game_board[i] == ' ':\\n return i\\n elif self.game_board[i] == player and \\\\\\n self.game_board[k] == player and \\\\\\n self.game_board[j] == ' ':\\n return j\\n return None\",\n \"def transit_next(self, vehicle, time):\\n events = []\\n vehicle.current += 1\\n cur_stop = vehicle.route[vehicle.current]\\n\\n # pickup passengers\\n trip_id = vehicle.id.split('_')[0]\\n for (end_stop, action) in self.stops[cur_stop['stop_id']][trip_id]:\\n logger.debug('[{}] {} Picking up passengers at {}'.format(time, vehicle.id, cur_stop['stop_id']))\\n vehicle.passengers[end_stop].append(action)\\n self.stops[cur_stop['stop_id']][trip_id] = []\\n\\n # dropoff passengers\\n for action in vehicle.passengers[cur_stop['stop_id']]:\\n logger.debug('[{}] {} Dropping off passengers at {}'.format(time, vehicle.id, cur_stop['stop_id']))\\n events.extend(action(time))\\n vehicle.passengers[cur_stop['stop_id']] = []\\n\\n try:\\n next_stop = vehicle.route[vehicle.current + 1]\\n except IndexError:\\n # trip is done\\n return events\\n\\n # schedule next leg of trip\\n time = next_stop['arr_sec'] - cur_stop['dep_sec']\\n events.append((time, partial(self.transit_next, vehicle)))\\n return events\",\n \"def next_player(board, prev_player):\\n opp = Othello.opponent(prev_player)\\n if Othello.any_legal_move(opp, board):\\n return opp\\n elif Othello.any_legal_move(prev_player, board):\\n return prev_player\\n return None\",\n \"def computer_driver_heuristic(self, pc):\\n if pc == self.departure_location:\\n return self.nearest_neigbor(pc)\\n else:\\n # encode state: State -> Generalized One hot vector\\n # print(len(self.idx_to_pc)+1)\\n encoded_vector = np.zeros(len(self.idx_to_pc)+1)\\n\\n # indices of locations FOR ENCODING\\n pickup_jobs_idx = [self.pc_to_idx[p]+1 for p in list(self.state.P_k.keys())] # +1 is to make room for the time dim\\n deliv_jobs_idx = [self.pc_to_idx[p]+1 for p in list(self.state.D_k.keys())]\\n\\n # indices of locations FOR PC READING\\n pickup_jobs_idx_read = [self.pc_to_idx[p] for p in list(self.state.P_k.keys())]\\n deliv_jobs_idx_read = [self.pc_to_idx[p] for p in list(self.state.D_k.keys())]\\n tasks = set(pickup_jobs_idx_read + deliv_jobs_idx_read)\\n\\n if len(tasks) > 0:\\n # set appropriate values at the index corresponding to the location\\n encoded_vector[pickup_jobs_idx] = -0.5\\n encoded_vector[deliv_jobs_idx] = 0.5\\n encoded_vector[self.pc_to_idx[pc]+1] = 1\\n\\n # # current time encoded as nb of seconds between 12pm and now/nb seconds between 12pm and 12am\\n total_nb_seconds = datetime.timedelta(hours=12, minutes=0)\\n cur_time = self.state.t_k.time()\\n cur_time = datetime.timedelta(hours=cur_time.hour, minutes=cur_time.minute) # nb of seconds from 12am\\n # # TODO this can further be noramlized as most values will be >0 (>6am)\\n cur_time = 2 * cur_time.seconds / total_nb_seconds.seconds - 1 # normalized time in [-1,1]\\n encoded_vector[0] = cur_time\\n\\n # predict decision\\n pred = self.heuristic_model.predict_proba(encoded_vector.reshape(1,-1))\\n\\n # take the most probable location among the remaining jobs\\n # # set proba to 0 if location not among remaining jobs\\n # print(\\\"##############\\\")\\n # print(\\\"shape of pred \\\", pred.shape)\\n # print(\\\"Number of locations considered : \\\", len(self.idx_to_pc))\\n print(\\\"Possible indices to choose from : \\\", tasks)\\n pred[0, list(set(range(0, len(self.idx_to_pc))) - set(pickup_jobs_idx_read + deliv_jobs_idx_read))] = 0\\n\\n idx_opt = np.argsort(pred[0,:])[-1] # most probable location (by its index) among remaining jobs\\n print(\\\"Index chosen : \\\", idx_opt )\\n return self.idx_to_pc[idx_opt]\\n\\n elif len(tasks) == 0:\\n return 0\\n\\n else:\\n raise ValueError('Problem with tasks, which has negative length...')\",\n \"def _get_next_cheapest_desired_card(diff_state):\\n # search for min within in Dict\\n # may optimize later\\n\\n next_card = CardEnum.NoCard\\n min_cost = 1e6 # Arbitrarily Large Number\\n\\n for key in list(diff_state.keys()):\\n if diff_state[key] is not None:\\n if diff_state[key] < min_cost:\\n next_card = key\\n min_cost = diff_state[key]\\n\\n return next_card\",\n \"def find_route(risk_map: MAP, destination: COORDINATE) -> int:\\n # Time for some Dijkstra! https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm\\n # Per the problem description cost is added when a position is entered, so we start at 0\\n heap = [(0, (0, 0))] # distance (risk), node\\n min_risk = defaultdict(lambda: math.inf, {(0, 0): 0})\\n seen = set()\\n while heap:\\n # Use heapq, as we want to select the next unvisited node with the lowest potential distance\\n risk, node = heappop(heap)\\n\\n if node == destination:\\n return risk\\n\\n if node in seen:\\n continue\\n\\n # For each node we visit, we check its unvisited neighbors & find the shortest distance\\n # (risk) to the starting node & update the current node accordingly\\n seen.add(node)\\n for neighbor_coord in iter_neighbors(*node):\\n if neighbor_coord not in risk_map:\\n continue\\n\\n tentative_risk = risk + risk_map[neighbor_coord]\\n if tentative_risk < min_risk[neighbor_coord]:\\n min_risk[neighbor_coord] = tentative_risk\\n heappush(heap, (tentative_risk, neighbor_coord))\",\n \"def find_destination_hub_and_leg_travel_time(destination):\\n milk_run_shipments = create_shipments_milk_run()\\n for shipment in milk_run_shipments:\\n for dest in shipment.milk_run.split('-'):\\n if dest == destination:\\n return shipment.hub, shipment.travel_time\\n return 'not found', 0\",\n \"def next_candidate():\\r\\n candidate_bidder = -1\\r\\n candidate_value = -1\\r\\n for n in range(len(bidders)):\\r\\n if (is_active[n] == 0 and cur_value(n) is not None\\r\\n and cur_value(n) > max(candidate_value, cur_bid)):\\r\\n candidate_value = bidders[n].values[cur_value_idx[n]]\\r\\n candidate_bidder = n\\r\\n return candidate_value, candidate_bidder\",\n \"def search_best_goal_node(self):\\n\\n dist_to_goal_list = [self.calc_dist_to_goal(n.x, n.y) for n in self.node_list]\\n goal_indexes = [\\n dist_to_goal_list.index(i)\\n for i in dist_to_goal_list\\n if i <= self.expand_dis\\n ]\\n\\n safe_goal_indexes = []\\n for goal_index in goal_indexes:\\n t_node = self.steer(self.node_list[goal_index], self.goal_node)\\n if self.check_collision(t_node, self.obstacle_list):\\n safe_goal_indexes.append(goal_index)\\n\\n if not safe_goal_indexes:\\n return None\\n\\n min_cost = min([self.node_list[i].cost for i in safe_goal_indexes])\\n for i in safe_goal_indexes:\\n if self.node_list[i].cost == min_cost:\\n return i\\n\\n return None\",\n \"def find_next(i, low, high):\\n print(\\\"Searching from {} to {}...\\\".format(low, high))\\n if low == high:\\n set_search_addr(i, low)\\n response = i.send(Compare())\\n\\n if response.value is True:\\n print(\\\"Found ballast at {}; withdrawing it...\\\".format(low))\\n i.send(Withdraw())\\n return low\\n return None\\n\\n set_search_addr(i, high)\\n response = i.send(Compare())\\n\\n if response.value is True:\\n midpoint = (low + high) // 2\\n return find_next(i, low, midpoint) or find_next(i, midpoint + 1, high)\",\n \"def _next_action(self) -> SingleBriberyAction:\\n self._current_rating = self.get_graph().eval_graph(self.get_briber_id())\\n if self._previous_rating is None:\\n self._previous_rating = self._current_rating\\n next_act = SingleBriberyAction(self)\\n try:\\n self._next_node = self.get_graph().get_random_customer(excluding=self._info_gained | self._bribed)\\n except IndexError:\\n print(f\\\"WARNING: {self.__class__.__name__} found no influential nodes, not acting...\\\", file=sys.stderr)\\n return next_act\\n if self._current_rating - self._previous_rating > self._max_rating_increase:\\n self._best_node = self._last_node\\n self._max_rating_increase = self._current_rating - self._previous_rating\\n maximum_bribe = min(self.get_resources(), self._bribe_to_max())\\n if self._c >= self._i and self._best_node is not None and maximum_bribe > 0:\\n next_act.add_bribe(self._best_node, maximum_bribe)\\n self._bribed.add(self._best_node)\\n self._info_gained = set()\\n self._c = 0\\n self._max_rating_increase = 0\\n self._best_node = 0\\n else:\\n if self._c >= self._i:\\n print(f\\\"WARNING: {self.__class__.__name__} has not found an influential node in {self._c} tries \\\"\\n f\\\"(intended maximum tries {self._i}), continuing search...\\\",\\n file=sys.stderr)\\n # Bid an information gaining bribe, which is at most k, but is\\n # smaller if you need to bribe less to get to the full bribe\\n # or don't have enough money to bid k.\\n next_act.add_bribe(self._next_node, min(self._bribe_to_max(), min(self.get_resources(), self._k)))\\n self._info_gained.add(self._next_node)\\n self._c = self._c + 1\\n self._last_node = self._next_node\\n self._previous_rating = self._current_rating\\n return next_act\",\n \"def __get_next_visit_node(self) -> str:\\r\\n node = None\\r\\n\\r\\n for visit in self.__priority_queue:\\r\\n # We can't visit the start node\\r\\n if visit.node_name == self.__fr:\\r\\n continue\\r\\n\\r\\n # Finds the lowest value node\\r\\n if node is None or visit.cost < node.cost:\\r\\n node = visit\\r\\n\\r\\n return node.node_name\",\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 find_next_step(start, end, paths):\\r\\n def find_paths(start, current, distance, paths, choices):\\r\\n \\\"\\\"\\\"\\r\\n Given the start point, and the current point, builds a dictionary indicating the first step\\r\\n and the minimum distance to the end using that step. Distance indicates the distance from\\r\\n current to end.\\r\\n \\\"\\\"\\\"\\r\\n # Find all paths resulting in the minimum distance\\r\\n options = []\\r\\n min_distance = min(paths[current].values())\\r\\n for option, distance in paths[current].items():\\r\\n if distance == min_distance:\\r\\n\\r\\n # If we find the beginning, break out\\r\\n if option == start:\\r\\n if option not in choices or choices[current] < distance + min_distance:\\r\\n choices[current] = distance + min_distance\\r\\n return\\r\\n\\r\\n # Add to list of options\\r\\n options.append(option)\\r\\n\\r\\n # For each path, recursively find minimal paths\\r\\n for option in options:\\r\\n find_paths(start, option, min_distance, paths, choices)\\r\\n\\r\\n choices = {}\\r\\n find_paths(start, end, 0, paths, choices)\\r\\n choices = sorted(choices.keys())\\r\\n return choices[0]\",\n \"def getNextWaypoint(self, request, context):\\n\\n waypointNumber = self.vehicle.commands.next -1\\n missionlist = self.vehicle.waypoints\\n if len(missionlist)==0:\\n waypointNumber = -1\\n dronePosition = droneconnect_pb2.Position(lat = float(0),\\n lon = float(0),\\n gpsAltitude = float(0))\\n else:\\n waypoint = missionlist[waypointNumber]\\n dronePosition = droneconnect_pb2.Position(lat = float(waypoint[0]),\\n lon = float(waypoint[1]),\\n gpsAltitude = float(waypoint[2]))\\n \\n return droneconnect_pb2.IndexedPosition(position = dronePosition, index = waypointNumber)\",\n \"def get_next_departure(self,day,link,current_time): \\n if link not in self.data[day]:\\n return None\\n import numpy as np\\n index=[np.searchsorted(self.data[day][link][0:,0],current_time)]\\n print(len(self.data[day][link]))\\n print(index) \\n if index[0] < len(self.data[day][link]):\\n return self.data[day][link][index[0]]\\n else:\\n return None\",\n \"def check_directions(next_door, current_node, goal_node, chip, crossroad, travelled_path, colide): \\n if next_door[2] < 0 or next_door[2] > 7:\\n return crossroad\\n\\n # Check if the node is off the grid\\n if next_door[0] < 0 or next_door[0] > chip.width - 1 or next_door[1] < 0 or next_door[1] > chip.height - 1:\\n return crossroad\\n\\n (x, y, z) = current_node.position\\n\\n # Check whether a connection is already being used\\n if chip.coordinates[z][y][x].connections[next_door].used:\\n return crossroad\\n\\n next_node = chip.coordinates[next_door[2]][next_door[1]][next_door[0]]\\n\\n neighbour = nd.Node(next_door, current_node, next_node.cost, next_node.cost + next_node.distance_to_goal)\\n\\n if neighbour != goal_node and chip.coordinates[next_door[2]][next_door[1]][next_door[0]].gate is not None:\\n return crossroad\\n\\n # Check whether the coordinate is already in the current path.\\n if neighbour in travelled_path:\\n return crossroad\\n\\n # Check whether neighbor is in open list and if it has a lower cost value\\n if add_to_crossroad(neighbour, crossroad, colide):\\n crossroad.append(neighbour)\\n\\n return crossroad\",\n \"def nearest_neighbor(A, cities):\\n return min(cities, key = lambda c: distance(c,A))\",\n \"def findDJI(startVert, endVert): \\n\\n dist = {}\\n dist[startVert] = 0\\n prev = {}\\n prev[startVert] = None\\n q = heap.Heap()\\n q.insert(startVert, dist[startVert])\\n while (q):\\n # current is the next unvisited, closest node to start\\n current = q.pop()\\n \\n # check to see if we found a better path to any\\n # of current's neighbors\\n for n in current.getConnections():\\n if n not in dist:\\n # we found a new node\\n dist[n] = dist[current] + current.getWeight(n)\\n prev[n] = current\\n q.insert(n, dist[n])\\n if dist[current] + current.getWeight(n) < dist[n]:\\n # we found a better path\\n dist[n] = dist[current] + current.getWeight(n)\\n prev[n] = current\\n q.decreaseKey(n, dist[n])\\n if endVert in dist:\\n return backtrack(startVert, endVert, prev)\\n else:\\n return None\",\n \"def find_best_match(organ: Organ, wait_list: WaitList,\\n weights: Dict[int, float]) -> Optional[Patient]:\\n # ANSI codes to emphasize output\\n bold_red, red, reset = '\\\\033[31;1m', '\\\\033[31m', '\\\\033[0m'\\n matches = wait_list.get_prioritized_patients(organ)\\n\\n # returns the patient with the highest priority within acceptable proximity\\n while len(matches) != 0:\\n patient = heapq._heappop_max(matches) # type: ignore\\n if organ.viability >= weights[patient.location] - 10:\\n return patient\\n\\n # in the event there are no matches\\n print(f'\\\\n{bold_red}The following organ has no suitable matches:'\\n f'\\\\n{red}{organ.__str__()}{reset}')\\n return None\",\n \"def _distance_next(self):\\n\\n self.distance = 10\\n\\n # Here a set index to 0 if the car is finishing a lap\\n # Also reset the farthest\\n if self.index > (len(self.x_trajectory) - 6) and self.closed:\\n self.index = 0\\n self.farthest = -1\\n self.laps += 1\\n\\n for w in range(self.index, self.index + 20):\\n\\n self.dist_point = math.sqrt((self.x_trajectory[w] - self.x)**2\\n + (self.y_trajectory[w] - self.y)**2)\\n\\n if self.dist_point < self.distance:\\n self.distance = self.dist_point\\n self.index = w\\n\\n if w >= (len(self.x_trajectory) - 1):\\n break\\n\\n self._calc_side()\\n\\n self.distance = self.distance * self.sign\\n\\n return self.distance\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6084116","0.5874696","0.5782421","0.57132584","0.5656202","0.56430805","0.5636324","0.5563873","0.5542704","0.5528435","0.5520394","0.5506145","0.5500587","0.54915744","0.54864365","0.5473194","0.54112583","0.53902376","0.53827214","0.53707117","0.5341262","0.5337884","0.53372943","0.5295279","0.529459","0.5290391","0.5285511","0.5191927","0.51877683","0.51746464","0.5166035","0.5151965","0.51511306","0.51489776","0.51421976","0.5141107","0.51382595","0.51297736","0.5126788","0.5124962","0.5115752","0.5097099","0.5093374","0.5084015","0.5070655","0.506457","0.5056255","0.50319684","0.5022835","0.50157356","0.5009709","0.5005682","0.5003595","0.49996692","0.49892446","0.4982369","0.4981863","0.49791604","0.4973989","0.49731562","0.49718148","0.49527395","0.49515653","0.49473602","0.49408457","0.49288553","0.49177328","0.49165356","0.49138787","0.49104238","0.48993877","0.48990944","0.48976326","0.48957354","0.48938057","0.48856187","0.48800933","0.48743254","0.48655593","0.4863852","0.48537588","0.4851601","0.48416907","0.48415813","0.48226643","0.48204198","0.48192006","0.48159054","0.48148945","0.4813733","0.48115844","0.48098773","0.48088095","0.48078185","0.48057663","0.48056376","0.48032275","0.48018214","0.48017174","0.47971898","0.4795388"],"string":"[\n \"0.6084116\",\n \"0.5874696\",\n \"0.5782421\",\n \"0.57132584\",\n \"0.5656202\",\n \"0.56430805\",\n \"0.5636324\",\n \"0.5563873\",\n \"0.5542704\",\n \"0.5528435\",\n \"0.5520394\",\n \"0.5506145\",\n \"0.5500587\",\n \"0.54915744\",\n \"0.54864365\",\n \"0.5473194\",\n \"0.54112583\",\n \"0.53902376\",\n \"0.53827214\",\n \"0.53707117\",\n \"0.5341262\",\n \"0.5337884\",\n \"0.53372943\",\n \"0.5295279\",\n \"0.529459\",\n \"0.5290391\",\n \"0.5285511\",\n \"0.5191927\",\n \"0.51877683\",\n \"0.51746464\",\n \"0.5166035\",\n \"0.5151965\",\n \"0.51511306\",\n \"0.51489776\",\n \"0.51421976\",\n \"0.5141107\",\n \"0.51382595\",\n \"0.51297736\",\n \"0.5126788\",\n \"0.5124962\",\n \"0.5115752\",\n \"0.5097099\",\n \"0.5093374\",\n \"0.5084015\",\n \"0.5070655\",\n \"0.506457\",\n \"0.5056255\",\n \"0.50319684\",\n \"0.5022835\",\n \"0.50157356\",\n \"0.5009709\",\n \"0.5005682\",\n \"0.5003595\",\n \"0.49996692\",\n \"0.49892446\",\n \"0.4982369\",\n \"0.4981863\",\n \"0.49791604\",\n \"0.4973989\",\n \"0.49731562\",\n \"0.49718148\",\n \"0.49527395\",\n \"0.49515653\",\n \"0.49473602\",\n \"0.49408457\",\n \"0.49288553\",\n \"0.49177328\",\n \"0.49165356\",\n \"0.49138787\",\n \"0.49104238\",\n \"0.48993877\",\n \"0.48990944\",\n \"0.48976326\",\n \"0.48957354\",\n \"0.48938057\",\n \"0.48856187\",\n \"0.48800933\",\n \"0.48743254\",\n \"0.48655593\",\n \"0.4863852\",\n \"0.48537588\",\n \"0.4851601\",\n \"0.48416907\",\n \"0.48415813\",\n \"0.48226643\",\n \"0.48204198\",\n \"0.48192006\",\n \"0.48159054\",\n \"0.48148945\",\n \"0.4813733\",\n \"0.48115844\",\n \"0.48098773\",\n \"0.48088095\",\n \"0.48078185\",\n \"0.48057663\",\n \"0.48056376\",\n \"0.48032275\",\n \"0.48018214\",\n \"0.48017174\",\n \"0.47971898\",\n \"0.4795388\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24597,"cells":{"query":{"kind":"string","value":"Generate an initial solution based on the Timeoriented Nearestneighbor heuristic proposed by Solomon."},"document":{"kind":"string","value":"def greedy_initial(self):\r\n sol = [] # [[0;2;5;0;4;6;0],[],...]\r\n sol_veh_type = [] # corresponding vehicle type for the solution\r\n route_way_time = []\r\n\r\n to_vist = [i+1 for i in range(store_num - 1)] # [1,5,8,...]\r\n itr = 0\r\n\r\n while len(to_vist) > 0 and itr < 500:\r\n itr += 1\r\n\r\n if itr <= small_veh_cnt:\r\n vehicle_type0 = 2\r\n elif itr <= small_veh_cnt + medium_veh_cnt:\r\n vehicle_type0 = 3\r\n else:\r\n vehicle_type0 = 5\r\n\r\n sol_veh_type.append(vehicle_type0)\r\n\r\n used_res = [0, 0, 0, 0] # used volume, and travel time of the vehicle, leave time, travel distance\r\n veh_rout = [0]\r\n\r\n # print '\\nA new vehicle will be used.'\r\n way_time = 0 # travel time of coming to the store + wait time at the store + operation time at this store\r\n while True:\r\n curr_cust = veh_rout[-1]\r\n\r\n next_one, way_time = self.time_nn(way_time, curr_cust, to_vist, used_res, len(veh_rout), vehicle_type0)\r\n next_cust, next_start = next_one[0], next_one[1]\r\n # print('next start', next_cust, next_start)\r\n if next_cust == 0: # next visiting customer is depot\r\n # print 'Get back to the depot, and ready for a new round.'\r\n veh_rout.append(next_cust)\r\n break\r\n\r\n else: # next visiting customer is a store\r\n used_res[0] += (num_demd[next_cust][0] * bskt_vol + num_demd[next_cust][1] * trsf_vol + (num_demd[next_cust][2] + \\\r\n num_demd[next_cust][3]) * milk_vol + num_demd[next_cust][4] * paper_bskt)\r\n used_res[2] = (next_start + oprt_t)\r\n used_res[3] += dist_mat[curr_cust, next_cust]\r\n\r\n\r\n veh_rout.append(next_cust)\r\n # print 'Vehicle used resource: ', used_res\r\n to_vist.remove(next_cust)\r\n\r\n sol.append(veh_rout)\r\n route_way_time.append(way_time)\r\n\r\n # print 'Last point 0 earliest leave time: ', int(used_res[-1]) / 60, ':', int(used_res[-1]) % 60\r\n # print 'Route %s is: ' % itr, veh_rout\r\n print('*'*10, 'Iteration:', itr, '*'*10)\r\n\r\n\r\n if len(to_vist) > 0:\r\n print('number of stores remained: ', len(to_vist))\r\n\r\n return sol, sol_veh_type, route_way_time"},"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 solve(self):\n # Use a trivial tour (1-2-3-...-N-1) to set the global upper bound.\n tour = list(range(self._N))\n upper_bound = sum([self._G[i][(i + 1) % self._N] for i in range(self._N)])\n trace = []\n\n # Start from a configuration with a single vertex.\n frontier = [BranchAndBoundConfiguration(self._G, self._N, [0], LOWER_BOUND_METHOD)]\n\n # Set the start time.\n start_time = time.time()\n\n # Branch and bound until the frontier set is empty or the time has expired.\n while frontier and (time.time() - start_time) < self._cutoff_time:\n # Fetch the most promising configuration.\n config = heappop(frontier)\n\n # Expand configuration by appending a vertex to the path.\n for v in range(self._N):\n try:\n expanded_config = config.expand(v)\n except ValueError:\n # Expanded configuration is not valid.\n continue\n if expanded_config.is_solution():\n # Update the global upper bound, if needed.\n this_solution = expanded_config.get_cycle_cost()\n if this_solution < upper_bound:\n # Log it.\n trace.append((time.time() - start_time, this_solution))\n # Update the best solution.\n upper_bound = this_solution\n tour = list(expanded_config.get_path())\n elif expanded_config.get_lower_bound() < upper_bound:\n # Add to the frontier set.\n heappush(frontier, expanded_config)\n return (upper_bound, [self._index_to_id[v] for v in tour], trace)","def get_shortest_route_floyd(network, start,destination, excludings=[]):\n\n # On récupère la liste des villes\n list_city = network[1].keys()\n \n # Si la ville de départ ou de fin n'existe pas\n if start not in list_city or destination not in list_city:\n return None\n\n # On retire les villes à exclure\n list_city = [x for x in list_city if x not in excludings]\n\n\n # Initialisation de se qu'on a besoin\n matrix = []\n distance = []\n n = len(list_city)\n\n \n # On construit la matrice adjacente où indique la distance si il existe une autoroute entre 2 villes\n for x in range(n): \n matrix.append( [] )\n distance.append( [] )\n for y in range(n):\n road_id = get_road_to(network,list_city[x],list_city[y])\n if road_id != None:\n matrix[x].append( get_length(network,road_id) )\n else:\n matrix[x].append( None )\n distance[x].append( [road_id] ) # Autoroute -> format: ['LA']\n\n\t \n # Algorithme de Floyd\n for k in range(n):\n for i in range(n):\n for j in range(n):\n if ( matrix[i][k] != None and matrix[k][j] != None ) and ( ( matrix[i][j] == None ) or ( matrix[i][j] > matrix[i][k] + matrix[k][j] ) ):\n matrix[i][j] = matrix[i][k] + matrix[k][j]\n\t\t \n\t\t # Hors Floyd / Ajout personnel\n if i != k and j != k: # Si i == k ou j == k, cela veut dire qu'on additionne un résultat supplémentaire à la case ij\n distance[i][j] = [] # Sinon ca signifie qu'on a trouvé un chemin plus court, du coup on supprime l'ancien chemin\n distance[i][j].extend( distance[i][k] ) # Chemin d'autoroute parcouru en plus -> format: ['LA','AH']\n distance[i][j].extend( distance[k][j] ) # Chemin d'autoroute parcouru en plus -> format: ['LA','AH']\n\n\t\t \n # On récupère simplement la liste des autoroutes parcourus\n idx_start = list_city.index( start )\n idx_destination = list_city.index( destination )\n distance_minimum = distance[ idx_start ][ idx_destination ]\n\n \n # Si on ne trouve aucune solution, on renvoie None\n if distance_minimum == [None]:\n distance_minimum = None\n \n return distance_minimum","def initialisationTurn(mazeWidth, mazeHeight, mazeMap, preparationTime, turnTime, player_location, opponentLocation, coins) :\n global route, currentcoin, meta_route, best_weight, best_path, coins_to_search, index\n\t#dists_matrix, routes_matrix = u.dists_from_each(coins + [playerLocation], mazeMap)\n coins_to_search = get_n_shortest(5, coins, player_location, dists_matrix)\n best_weight = float(\"inf\")\n best_path = []\n exhaustive(coins_to_search, player_location, [], 0, dists_matrix)\n meta_route = [player_location] + best_path\n route = u.location_list_to_route(meta_route, routes_matrix)\n index = 1\n currentcoin = meta_route[1]","def second_heuristic(self):\r\n directions = [[-1, -1], [-1, 1], [1, 1], [1, -1]]\r\n # aceasta matrice indica valoarea pe care o are mutarea unei piese pe o celula aleasa\r\n # se va aduna la media ponderilor adunate in lista weights\r\n\r\n # mijlocul tablei este punctul cel mai vulnerabil\r\n # in timp ce lateralele sunt sigure,iar linia bazei transforma piesa in rege\r\n\r\n points = [[0, 4, 0, 4, 0, 4, 0, 4],\r\n [4, 0, 3, 0, 3, 0, 3, 0],\r\n [0, 3, 0, 2, 0, 2, 0, 4],\r\n [4, 0, 2, 0, 1, 0, 3, 0],\r\n [0, 3, 0, 1, 0, 2, 0, 4],\r\n [4, 0, 2, 0, 1, 0, 3, 0],\r\n [0, 3, 0, 2, 0, 2, 0, 4],\r\n [4, 0, 4, 0, 4, 0, 4, 0]]\r\n\r\n weights = [0 for i in range(4)]\r\n whites, blacks = 0, 0\r\n for i in range(8):\r\n for j in range(8):\r\n\r\n # numaram discurile de fiecare culoarea\r\n blacks += 1 if self.matrix[i][j] in ['N', 'n'] else 0\r\n whites += 1 if self.matrix[i][j] in ['A', 'a'] else 0\r\n\r\n if self.matrix[i][j] in [self.current_player, self.current_player.upper()]:\r\n\r\n # daca e piesa normala\r\n if self.matrix[i][j] == self.current_player:\r\n weights[0] += 4\r\n\r\n # cat de aproape este piesa de a deveni rege ( nr de linii din tabla - cate mai are pana ajunge pe ultima linie)\r\n\r\n # cu cat se apropie piesa mai multe de a deveni rege, scorul creste( negru - rege pentru i=0, alb -rege pentru i =7)\r\n if self.matrix[i][j] == 'n':\r\n weights[1] += (7 - i)\r\n elif self.matrix[i][j] == 'a':\r\n weights[1] += i\r\n else:\r\n # daca e piesa rege\r\n weights[0] += 8\r\n\r\n # cat de aproape este piesa rege de celelalte piese\r\n for d in directions:\r\n if self.matrix[i][j] == self.current_player.upper():\r\n # gaseste pe diagonala in directia d, o piesa adversara,daca exista\r\n x, y = self.find_piesa(i, j, d)\r\n if x and y:\r\n weights[2] += (x - i) * (x - i) + (y - j) * (y - j)\r\n vx = d[0] + i\r\n vy = d[1] + j\r\n back_x = i - d[0]\r\n back_y = j - d[1]\r\n next_x, next_y = vx + d[0], vy + d[1]\r\n # piesele pe care le poate captura jucatorul, daca e piesa rege are un scor mai mare\r\n if self.bounded(vx, vy) and self.matrix[vx][vy] in [self.opponent(), self.opponent().upper()]:\r\n if self.bounded(next_x, next_y) and self.matrix[next_x][next_y] == '.':\r\n if self.matrix[next_x][next_y] == self.opponent().upper():\r\n weights[3] += 7\r\n else:\r\n weights[3] += 4\r\n # piese care pot fi capturate; la fel daca este piesa rege atunci se scade mai mult scorul\r\n if self.bounded(vx, vy) and self.matrix[vx][vy] in [self.opponent(), self.opponent().upper()]:\r\n if self.bounded(back_x, back_y) and self.matrix[back_x][back_y] == '.':\r\n if self.matrix[vx][vy] == self.opponent().upper():\r\n weights[3] -= 6\r\n else:\r\n weights[3] -= 3\r\n # adunam piesa la media sumei date pentru a face AI-ul in caz de egalitate a scorului\r\n # sa imi aleaga piesa care ma pozitioneaza mai bine\r\n if self.move:\r\n return sum(weights) / 4 + points[self.move[0]][self.move[1]]\r\n return sum(weights) / 4\r\n\r\n def __str__(self):\r\n s = ' '\r\n for i in range(8):\r\n s += str(i) + ' '\r\n s += '\\n'\r\n for index, line in enumerate(self.matrix):\r\n s += str(chr(index + ord('a'))) + ' '\r\n for el in line:\r\n s += str(el) + ' '\r\n s += '\\n'\r\n\r\n return s","def rrt_search(self):\n self.tree.AddVertex(self.start_config)\n self.tree.AddEdge(self.start_config, self.start_config)\n\n while True:\n x_new, x_nearest = self.new_and_near()\n if x_new is None:\n # print(\"it's None\")\n continue\n # connect shortest valid edge\n # print(\"new point\", x_new)\n self.connect_to_point(x_nearest, x_new)\n\n # probabilistically check if solution found\n if self.goal_config in self.tree.vertices:\n print(\"find it\")\n path = self.planning_env.reconstruct_path(self.tree.edges, self.start_config, self.goal_config)\n if path is not None:\n return path\n\n if self.name=='rrtstar' and self.tree.samples_taken > 10:\n return []\n # # check if can connect to goal after generating max_samples\n if self.tree.samples_taken >= self.tree.max_samples:\n return []","def _optimise(self):\n better = True\n self.solutions = set()\n\n # Rebuild the neighbours\n self.neighbours = {}\n\n for i in self.heuristic_path:\n self.neighbours[i] = []\n\n for j, dist in enumerate(TSP.edges[i]):\n if dist > 0 and j in self.heuristic_path:\n self.neighbours[i].append(j)\n\n # Restart the loop each time we find an improving candidate\n while better:\n better = self.improve()\n # Paths always begin at 0 so this should manage to find duplicate\n # solutions\n self.solutions.add(str(self.heuristic_path))\n\n self.save(self.heuristic_path, self.heuristic_cost)","def solve_tsp(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix, params=[]):\n drop_off_dict = {}\n car_path = []\n home_map = {}\n home_indexes = convert_locations_to_indices(list_of_homes, list_of_locations)\n\n start = list_of_locations.index(starting_car_location)\n graph, msg = adjacency_matrix_to_graph(adjacency_matrix)\n all_paths = dict(nx.all_pairs_dijkstra(graph))\n\n start_in_home = start in home_indexes\n if start in home_indexes:\n home_indexes.remove(start)\n home_indexes.insert(0, start)\n home_count = 0;\n\n for home in home_indexes:\n #print(home, end = \" \")\n home_map[home_count] = home\n home_count += 1\n # Instantiate the data problem.\n #print(len(home_map))\n data = create_data_model(home_indexes, 0)\n\n # Create the routing index manager.\n manager = pywrapcp.RoutingIndexManager(len(data['locations']),\n data['num_vehicles'], data['depot'])\n\n #print(manager.NodeToIndex(15))\n # Create Routing Model.\n routing = pywrapcp.RoutingModel(manager)\n\n def distance_callback(from_index, to_index):\n \"\"\"Returns the distance between the two nodes.\"\"\"\n # Convert from routing variable Index to distance matrix NodeIndex.\n #print(home_map[to_index], end = \" \")\n from_index = manager.IndexToNode(from_index)\n to_index = manager.IndexToNode(to_index)\n dist_to = all_paths.get(home_map[from_index])[0][home_map[to_index]]\n #if from_index >= 25 or to_index >= 25:\n # print(\"from\" if from_index >= 25 else \"to\", end = \" \")\n #dist_to = all_paths[from_index][0][to_index]\n return dist_to\n\n transit_callback_index = routing.RegisterTransitCallback(distance_callback)\n\n # Define cost of each arc.\n routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)\n\n # Setting first solution heuristic.\n \"\"\"\n search_parameters = pywrapcp.DefaultRoutingSearchParameters()\n search_parameters.first_solution_strategy = (\n routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)\n \"\"\"\n\n search_parameters = pywrapcp.DefaultRoutingSearchParameters()\n search_parameters.local_search_metaheuristic = (\n routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)\n search_parameters.time_limit.seconds = 3\n #search_parameters.log_search = True\n\n # Solve the problem.\n assignment = routing.SolveWithParameters(search_parameters)\n\n # if assignment:\n # print_solution(manager, routing, assignment)\n # Print solution on console.\n\n if start in home_indexes:\n drop_off_dict[start] = [start]\n\n\n index = routing.Start(0)\n car_path.append(start)\n\n while not routing.IsEnd(index):\n previous_index = manager.IndexToNode(index)\n index = assignment.Value(routing.NextVar(index))\n\n car_path.pop();\n to_index = manager.IndexToNode(index)\n path_to = all_paths.get(home_map[previous_index])[1][home_map[to_index]]\n drop_off_dict[home_map[to_index]] = [home_map[to_index]]\n #print(to_index, end = ' ')\n car_path.extend(path_to)\n #route_distance += routing.GetArcCostForVehicle(previous_index, index, 0)\n # for i in car_path:\n # print(i)\n if start in drop_off_dict.keys() and not start_in_home:\n drop_off_dict.pop(start, None)\n\n return car_path, drop_off_dict","def annealing(nodes, distances, maxTime, ans):\n\n #edge cases\n if len(nodes) == 0:\n ans[\"path\"] = []\n ans[\"cost\"] = 0\n return\n if len(nodes) == 1:\n ans[\"path\"] = nodes\n ans[\"cost\"] = 0\n return\n if len(nodes) == 2:\n ans[\"path\"] = nodes\n ans[\"cost\"] = totalDist(nodes, distances)\n return\n\n #Picking a starting tour\n currPath = generateStartingTour(nodes, distances)\n currCost = totalDist(currPath, distances)\n\n startingAnnealingTime = time.time()\n maxTemperature = maxTime - startingAnnealingTime + 0.05\n avg = 0\n while True:\n #check if time is up\n t = time.time()\n if t > maxTime:\n break\n \n #check if current path is best path\n if currCost < ans[\"cost\"]:\n ans[\"path\"] = currPath\n ans[\"cost\"] = currCost\n #print(ans[\"cost\"])\n\n #try a neighbor\n skel = randomNeighborSkeleton(currPath, currCost, distances)\n if skel[0] == 1:\n i = skel[1]\n j = skel[2]\n newCost = skel[3]\n else:\n i = skel[1]\n newCost = skel[2]\n\n currTemperature = maxTemperature - (t - startingAnnealingTime)\n\n avg = (avg * 1000 + abs(currCost-newCost)) / 1001\n\n #move to neighbor with some probability\n if random.random() < chance(currCost, newCost, currTemperature, maxTemperature, avg):\n if skel[0] == 1:\n contiguousFlip(currPath, i, j)\n else:\n consecutiveFlip(currPath, i)\n currCost = newCost","def aStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE ***\"\n def djikstra(Estado_Inicial):\n from util import PriorityQueue\n Fila_Estados = PriorityQueue() # cria fila de prioridade\n Fila_Estados.push((Estado_Inicial, []), 0) # insere tupla do estado inicial e vetor, com prioridade zero\n Distancia = dict() # cria dicionário para guardar distancia (afim de comparação)\n Distancia[Estado_Inicial] = 0 # seta distância inicial = 0\n while(not Fila_Estados.isEmpty()): # enquanto fila não está vazia,\n Estado_Atual, Caminho = Fila_Estados.pop() # desempilha estado atual e caminho até então\n if problem.isGoalState(Estado_Atual): # se estado atual é o desejado,\n return Caminho # retorna caminho\n for (Sucessor, Acao, Custo) in problem.getSuccessors(Estado_Atual): # verifica sucessores\n if Sucessor not in Distancia or Distancia[Sucessor] > Distancia[Estado_Atual] + Custo + heuristic(Sucessor, problem):\n Distancia[Sucessor] = Distancia[Estado_Atual] + Custo + heuristic(Sucessor, problem) # atualiza distância de acordo com sucessor\n Fila_Estados.push((Sucessor, Caminho + [Acao]), Distancia[Sucessor])\n return djikstra(problem.getStartState()) # recursividade","def get_heuristic(self, state):\n\n def get_manhattan_distance(coord_a, coord_b):\n \"\"\"Returns the manhattan distance between coord_a and coord_b.\"\"\"\n return abs(coord_a.x - coord_b.x) + abs(coord_a.y - coord_b.y)\n\n \n def get_num_obstacles(coord_a, coord_b):\n \"\"\"Returns the number of obstacles (wriggler segments or walls) between\n coord_a and coord_b.\n \n This function assumes that coord_b is larger (in either/both x and y)\n than coord_a.\n \"\"\"\n obstacle_count = 0\n \n for x in range(coord_a.x, coord_b.x + 1):\n for y in range(coord_a.y, coord_b.y + 1):\n coord = Coordinate(x, y)\n if coord in self.wall_coords or coord in state:\n obstacle_count += 1\n \n return obstacle_count\n\n\n head_coord = state.wriggler_list[0].get_head()\n tail_coord = state.wriggler_list[0].get_tail()\n \n head_manhattan_distance = get_manhattan_distance(head_coord, self.goal_coord)\n tail_manhattan_distance = get_manhattan_distance(tail_coord, self.goal_coord)\n \n # Calculate and return heuristic value depending on which heuristic to use\n if self.heuristic == Heuristic.MANHATTAN_DIST:\n # Return the shortest Manhattan distance of wriggler0's tail or head to the goal\n return min(head_manhattan_distance, tail_manhattan_distance)\n \n else: # self.heuristic == Heuristic.NUM_OBSTACLES:\n # Return the number of obstacles between wriggler0's tail/head to the goal\n # The tail/head is selected based on which is closer to the goal\n if head_manhattan_distance <= tail_manhattan_distance:\n # The head is closer or the same distance away\n return get_num_obstacles(head_coord, self.goal_coord)\n \n else:\n # The tail is closer\n return get_num_obstacles(tail_coord, self.goal_coord)","def process_solution(self, solution: dict) -> (list, float):\n start_time = time() * 1000\n nodes = self.application.nodes()\n start = np.min(nodes)\n # fill route with None values\n route = [None] * len(self.application)\n # get nodes from sample\n # NOTE: Prevent duplicate node entries by enforcing only one occurrence per node along route\n logging.info(str(solution.items()))\n\n for (node, timestep), val in solution.items():\n if val:\n logging.info((node, timestep))\n if val and (node not in route):\n route[timestep] = node\n\n # check whether every timestep has only 1 node flagged\n for i in nodes:\n relevant_nodes = []\n relevant_timesteps = []\n for (node, timestep) in solution.keys():\n if node == i:\n relevant_nodes.append(solution[(node, timestep)])\n if timestep == i:\n relevant_timesteps.append(solution[(node, timestep)])\n if sum(relevant_nodes) != 1 or sum(relevant_timesteps) != 1:\n # timestep or nodes have more than 1 or 0 flags\n return None, round(time() * 1000 - start_time, 3)\n\n # check validity of solution\n if sum(value == 1 for value in solution.values()) > len(route):\n logging.warning(\"Result is longer than route! This might be problematic!\")\n return None, round(time() * 1000 - start_time, 3)\n\n # run heuristic replacing None values\n if None in route:\n # get not assigned nodes\n nodes_unassigned = [node for node in list(nodes) if node not in route]\n nodes_unassigned = list(np.random.permutation(nodes_unassigned))\n for idx, node in enumerate(route):\n if node is None:\n route[idx] = nodes_unassigned[0]\n nodes_unassigned.remove(route[idx])\n\n # cycle solution to start at provided start location\n if start is not None and route[0] != start:\n # rotate to put the start in front\n idx = route.index(start)\n route = route[idx:] + route[:idx]\n\n # print route\n parsed_route = ' ->\\n'.join([f' Node {visit}' for visit in route])\n logging.info(f\"Route found:\\n{parsed_route}\")\n return route, round(time() * 1000 - start_time, 3)","def aStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE ***\"\n\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n n = Directions.NORTH\n e = Directions.EAST\n\n result = []\n qu = util.PriorityQueue()\n visited = set([])\n current = (problem.getStartState(), \"\", 0)\n qu.update(current, 0)\n costs = {}\n parents = {}\n parents[problem.getStartState()] = (problem.getStartState(), \"\")\n\n while not qu.isEmpty():\n cost, current = qu.pop()\n visited.add(current[0])\n\n if problem.isGoalState(current[0]):\n result = current[0]\n break\n\n for each in problem.getSuccessors(current[0]):\n if each[0] not in visited:\n qu.update(each, cost + each[2] + heuristic(each[0], problem))\n if each[0] not in costs:\n costs[each[0]] = cost + each[2]\n parents[each[0]] = (current[0], each[1])\n elif costs[each[0]] > cost + each[2] + heuristic(each[0], problem):\n costs[each[0]] = cost + each[2] + heuristic(each[0], problem)\n parents[each[0]] = (current[0], each[1])\n\n path = []\n while parents[result][0] != result:\n path.append(parents[result][1])\n result = parents[result][0]\n\n path.reverse()\n result = []\n for each in path:\n if each == \"South\":\n result.append(s)\n elif each == \"West\":\n result.append(w)\n elif each == \"North\":\n result.append(n)\n elif each == \"East\":\n result.append(e)\n\n return result\n util.raiseNotDefined()\n\n util.raiseNotDefined()","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 findHeuristic(self, _, __):\n popSize = 100\n retain = 0.25\n random_select = 0.1\n mutate = 0.1\n\n popList = self.populationList(popSize)\n\n solved = False\n count = 0\n while not solved:\n # evolves current\n popList = (self.evolve(popList, retain, random_select, mutate))\n# print(popList) # for troubleshooting\n for i in popList:\n if (self.fitness(i) == 0):\n print(\"solution: \", i)\n solved = True\n break\n # if plateus at a local minima, then end after 50 generations\n if count >= 50:\n if (self.fitness(i) <= 10):\n print(\"solution: \", i)\n solved = True\n break\n if solved is True:\n break\n print(\"-----------------\")\n\n # will modify mutation, random_select and retain values to help leave a\n # local minima. More randomness the longer it takes up to specific points\n if count % 3 == 0:\n if mutate < 0.2:\n mutate += 0.01\n if random_select < 0.3:\n random_select += 0.01\n count += 1\n\n return exit(0)","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 calculate_path(self):\n #Se repite el ciclo para el número especificado de veces\n for i in range(self.iterations):\n for ant in self.ants:\n ant.setup_ant()\n while not ant.final_node_reached:\n #Seleccion aleatoria del nodo a visitar\n node_to_vist = self.select_next_node(self.map.nodes_array[int(ant.actual_node[0])][int(ant.actual_node[1])])\n #Mover la hormiga al siguiente nodo seleccionado al azar\n ant.move_ant(node_to_visit)\n #Compruebe si se ha alcanzado la solución\n ant.is_final_node_reached()\n #Agregar la ruta resultante a la lista de rutas\n self.add_to_path_results(self.delete_loops(ant.get_visited_nodes()))\n # Habilitar a la hormiga para otra busqueda\n ant.enable_start_new_path()\n \n # Actualizar el nivel global de feromonas\n self.pheromone_update()\n self.best_result = self.paths[0]\n\n #Vaciar la lista de rutas\n self.empty_paths()\n print('Iteration: ', i, 'lenght of the path: ', len(self.best_result))\n return self.best_result","def heuristic(self):\r\n # 1.\r\n blacks, whites = 0, 0\r\n weights = [0 for _ in range(6)]\r\n directions = [[-1, -1], [-1, 1], [1, 1], [1, -1]]\r\n user_dir = directions[:2] if self.current_player == 'n' else directions[2:]\r\n for i in range(8):\r\n for j in range(8):\r\n blacks += 1 if self.matrix[i][j] in ['N', 'n'] else 0\r\n whites += 1 if self.matrix[i][j] in ['A', 'a'] else 0\r\n if self.matrix[i][j] == self.current_player or self.matrix[i][j] == self.current_player.upper():\r\n\r\n # numarul de piese rege\r\n if self.matrix[i][j] == self.current_player.upper():\r\n weights[1] += 7.75\r\n\r\n # numarul de piese normale\r\n else:\r\n weights[0] += 5\r\n\r\n # numarul de piese de pe baseline in functie de tipul de piesa\r\n # conform strategiilor de joc este o strategie buna sa ai cat mai multe\r\n # piesa pe baseline pentru a preveni creare de piese de tip rege ale adversarului\r\n if self.current_player in ['n', 'N']:\r\n if i == 7:\r\n weights[2] += 4\r\n elif self.current_player in ['a', 'A']:\r\n if i == 0:\r\n weights[2] += 4\r\n\r\n # numarul de piese din mijlocul tablei\r\n # la fel este o strategie buna pentru atac\r\n if 3 <= i <= 4 and 3 <= j <= 4:\r\n weights[3] += 2\r\n\r\n # numar piese vulnerabile\r\n # adica piese ce pot fi capturate de oponent la urmatoare tura\r\n for d in user_dir:\r\n\r\n vx = d[0] + i\r\n vy = d[1] + j\r\n back_x = i - d[0]\r\n back_y = j - d[1]\r\n next_x, next_y = vx + d[0], vy + d[1]\r\n if self.bounded(vx, vy) and self.matrix[vx][vy] in [self.opponent(), self.opponent().upper()]:\r\n if self.bounded(back_x, back_y) and self.matrix[back_x][back_y] == '.':\r\n weights[4] -= 3\r\n if self.bounded(vx, vy) and self.matrix[vx][vy] in [self.opponent(), self.opponent().upper()]:\r\n if self.bounded(next_x, next_y) and self.matrix[next_x][next_y] == '.':\r\n # daca elimin o piesa rege este o mutare mai buna\r\n if self.matrix[vx][vy] == self.opponent().upper():\r\n weights[5] += 10\r\n else:\r\n weights[5] += 7\r\n\r\n diff = (blacks - whites) if self.current_player == 'n' else (whites - blacks)\r\n # cand sunt mai putin piese, AI adopta o tactica mai ofensiva\r\n if blacks + whites <= 10:\r\n return sum(weights) + diff\r\n return sum(weights)","def solver(graph,homes,source,home_clusters,all_pairs_distances,all_pairs_shortest_paths):\n\n car_path = [get_car_path(graph,home_clusters,source,all_pairs_distances,all_pairs_shortest_paths, \n source_in_clusters = B1, christofides = B2) for B1 in [False,True] for B2 in [False,True]]\n\n dropoffs = [cluster_solver_utils.nearest_dropoff_efficient(graph,path,homes,all_pairs_distances) for path in car_path]\n cost = [cluster_solver_utils.eval_cost_efficient(graph,car_path[i],dropoffs[i],all_pairs_distances) for i in range(len(car_path))]\n\n minimum_cost = min(cost)\n idx = cost.index(minimum_cost)\n\n return minimum_cost, dropoffs[idx], car_path[idx]","def optimal_route(graph,homes,source):\n number_of_homes = len(homes)\n all_pairs_distances = dict(nx.shortest_path_length(graph, weight = 'weight'))\n all_pairs_shortest_paths = dict(nx.shortest_path(graph, weight = 'weight'))\n homes_subgraph = tsp_routines.complete_shortest_path_subgraph_efficient(graph,homes,all_pairs_distances)\n num_clusters_to_clustering = clustering_routines.all_k_clusters(homes_subgraph,number_of_homes)\n \n cluster_list = range(1,number_of_homes+1)\n optimal_cost = np.Inf\n optimal_dropoffs = dict()\n optimal_route = []\n optimal_num_clusters = 0\n\n\n for num_clusters in cluster_list:\n home_clusters = num_clusters_to_clustering[num_clusters]\n cost, dropoffs, route = solver(graph,homes,source,home_clusters,all_pairs_distances,all_pairs_shortest_paths)\n if cost < optimal_cost:\n optimal_cost = cost\n optimal_route = route \n optimal_dropoffs = dropoffs\n optimal_num_clusters = num_clusters\n\n return optimal_cost, optimal_dropoffs, optimal_route, optimal_num_clusters","def cornersHeuristic(state, problem):\n corners = problem.corners # These are the corner coordinates\n walls = problem.walls # These are the walls of the maze, as a Grid (game.py)\n \"*** YOUR CODE HERE ***\"\n \"\"\"\n En este ejercicio me he dado cuenta de un problema de mi definición del espacio de estados:\n - El espacio de estados consiste en tuplas ((x,y), grid), donde (x,y) es la posición en coordenadas\n y grid es la tabla de true/false.\n - El problema es que yo he pensado la tabla grid en forma de matriz matemática, de manera que los índices\n no van de acuerdo con la posición de las esquinas, sinó con los índices de una matriz.\n Para solucionar este problema sin tener que modificar todo lo anterior (dado que no me queda tiempo) lo que he\n tenido que hacer es crear una lista y añadir de forma ordenada los valores true/false, para que se corresponda\n cada uno con su esquina.\n \n Mi heurística consiste en lo siguiente:\n * Calculo la distancia desde la posición en la que me sitúo hasta todos los corners no visitados (los que aún\n tienen comida) y me quedo con la mínima de estas distancias, y con el corner que me de esa mínima.\n * Calculo la distancia desde ese corner (el mínimo de antes) hasta todos los otros posibles corners no visitados\n y de nuevo me quedo con la mínima distancia y con el corner que me da esa mínima.\n * Repito este proceso hasta que no queden corners.\n Entonces lo que hago es definir una nueva lista de corners, newListOfCorners que irá extrayendo los corners a medida\n que su distanca sea calculada. Por ejemplo, si tengo los cuatro corners con comida y estoy en una posición \n aleatoria, la lista newListOfCorners estará llena. Se calculará la distancia a cada corner y el corner que de la \n mínima será extraído de newListOfCorners. Entonces se calculará la distancia desde este corner hasta los restantes\n tres corners de newListOfCorners y el corner de esos tres que me de la mínima será extraído de la lista. Etc...\n \"\"\"\n\n # Ordenamos la lista de True's y False's para que vaya acorde con el orden de la lista corners:\n visitedCorners = []\n visitedCorners.append(state[1][1][0])\n visitedCorners.append(state[1][0][0])\n visitedCorners.append(state[1][1][1])\n visitedCorners.append(state[1][0][1])\n corners = list(corners) # De aquí saco una lista que contenga los corners ordenados.\n # Ahora los corners y la lista de visitedCorners contendrán la información de forma ordenada y coherente\n minimum = 9999999999999999 # Defino un mínimo muy grande para asegurarme que nunca sea superado\n total = 0 # Inicializo el total a cero\n newListOfCorners = [] # Creo una nueva lista para añadir los corners no estudiados\n for corner in corners: # Primero vamos a llenar la lista de corners con los que me interesen: los que tienen comida\n if visitedCorners[corners.index(corner)]: # Miramos que el corner tenga comida, sino pasamos\n newListOfCorners.append(corner) # Si tiene comida, lo añadimos\n minimCorner = corners[0] # Inicializo el minimCorner a un corner aleatorio para que no me de problemas más tarde\n actualState = state[0] # Lo mismo\n\n while not len(newListOfCorners) == 0: # Mientras la lista no esté vacía...\n for corner in newListOfCorners: # Cogemos un corner de la lista\n distanceToCorner = manhattanHeuristicToCorners(actualState, corner) # Calculamos dist. a corner\n if distanceToCorner < minimum: # Calculamos el mínimo\n minimum = distanceToCorner\n minimCorner = corner\n total += minimum # Y lo añadimos al total\n actualState = minimCorner # Reactualizamos cada variable para volver a empezar el bucle\n minimum = 9999999999999999999999999999999\n newListOfCorners.remove(minimCorner)\n return total","def extra(maze):\n # TODO: Write your code here\n heuristic_lookup = {} \n objs = maze.getObjectives()\n corner_list = maze.getObjectives()\n start = maze.getStart()\n path = []\n dim = maze.getDimensions()\n visited = {}\n lookup_table = {}\n p_queue = []\n edgeset = []\n mintree = {}\n start_heuristic = 0 + multi_dot_heuristic_query(maze, start, objs, edgeset, mintree) * 2\n heuristic_lookup[(start, tuple(objs))] = start_heuristic\n start_state = state(start, corner_list)\n lookup_table[state(start, corner_list)] = (start_heuristic, 0, state((-2, -2)))\n p_queue.append((start_heuristic, state(start, corner_list)))\n while p_queue:\n pair = p_queue.pop(0)\n visited[pair[1]] = lookup_table.get(pair[1])[2]\n if not pair[1].getlist():\n current_state = pair[1]\n while current_state != start_state:\n path.append(current_state.getpos())\n current_state = visited.get(current_state)\n path.append(start)\n path.reverse()\n return path\n else: \n list_of_neighbors = maze.getNeighbors(pair[1].getpos()[0], pair[1].getpos()[1])\n for coordinates in list_of_neighbors:\n current_state = state(coordinates)\n if coordinates in pair[1].getlist():\n new_list = copy.copy(pair[1].getlist())\n new_list.remove(coordinates)\n current_state = state(coordinates, new_list)\n else:\n current_state = state(coordinates, pair[1].getlist()) \n if current_state in visited:\n continue\n if current_state in lookup_table:\n if (lookup_table.get(current_state)[0], current_state) in p_queue:\n cost = lookup_table.get(pair[1])[1] + 1\n queried_heuristic = 0\n if (current_state.getpos(), tuple(current_state.getlist())) in heuristic_lookup:\n queried_heuristic = heuristic_lookup.get((current_state.getpos(), tuple(current_state.getlist())))\n else:\n queried_heuristic = multi_dot_heuristic_query(maze, current_state.getpos(), current_state.getlist(), edgeset, mintree) * 2\n heuristic_lookup[(current_state.getpos(), tuple(current_state.getlist()))] = queried_heuristic\n heuristic = queried_heuristic + cost\n old_heuristic = lookup_table.get(current_state)[0]\n if heuristic < lookup_table.get(current_state)[0]:\n lookup_table[current_state] = (heuristic, cost, pair[1])\n p_queue.remove((old_heuristic, current_state))\n bisect.insort(p_queue, (heuristic, current_state))\n else:\n cost = lookup_table.get(pair[1])[1] + 1\n queried_heuristic = 0\n if (current_state.getpos(), tuple(current_state.getlist())) in heuristic_lookup:\n queried_heuristic = heuristic_lookup.get((current_state.getpos(), tuple(current_state.getlist()))) \n else:\n queried_heuristic = multi_dot_heuristic_query(maze, current_state.getpos(), current_state.getlist(), edgeset, mintree) * 2\n heuristic_lookup[(current_state.getpos(), tuple(current_state.getlist()))] = queried_heuristic\n heuristic = queried_heuristic + cost\n lookup_table[current_state] = (heuristic, cost, pair[1])\n bisect.insort(p_queue, (heuristic, current_state))\n\n return []","def solve(self):\n smallest_f = self.get_smallest_f_cost_unvisited_node()\n smallest_f_node = smallest_f[0]\n\n if smallest_f[1] > 1:\n current_node = self.get_smallest_h_cost_unvisited_node()\n else:\n current_node = smallest_f_node\n if current_node.f_cost == self.inf:\n return\n\n self.set_h_cost(current_node)\n self.unvisited_pos.remove(current_node.pos)\n self.visited_pos.append(current_node.pos)\n neighbours = algo_utils.get_neighbours(current_node, self.grid, self.wall_pos)\n\n for neigh in neighbours:\n neighbour_dist = neigh.g_cost\n current_dist = current_node.g_cost\n new_dist = current_dist + 1\n if neighbour_dist < new_dist:\n continue\n neigh.g_cost = new_dist\n self.set_h_cost(neigh)\n mix_neigh = {neigh.pos: neigh.g_cost}\n self.mix.update(mix_neigh)\n mix_current = {current_node.pos: current_node.g_cost}\n self.mix.update(mix_current)\n\n smallest_f = self.get_smallest_f_cost_unvisited_node()\n smallest_f_node = smallest_f[0]\n smallest_h_node = self.get_smallest_h_cost_unvisited_node()\n\n if (\n self.end_pos not in self.unvisited_pos\n or algo_utils.get_smallest_g_cost_unvisited_node(\n self.grid, self.unvisited_pos\n ).g_cost\n == self.inf\n ):\n for key, value in self.mix.items():\n self.mix[key] = round((value * 1.0) / self.end_node.g_cost, 3)\n self.backtrack_path(self.end_node)\n else:\n if smallest_f[1] > 1:\n current_node = smallest_h_node\n else:\n current_node = smallest_f_node\n self.solve()","def aStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE ***\"\n # Initialize data structures\n parent_node = {}\n path_to_node = {}\n priority_queue = util.PriorityQueue()\n\n p_c = 0.5\n h_c = 1 - p_c\n\n # Get the start node\n start_node = problem.getStartState()\n parent_node[start_node] = None\n path_to_node[start_node] = []\n priority_queue.update(start_node, 0)\n\n #goal_found = False\n\n while not priority_queue.isEmpty():\n # Get the next node\n node_to_expand = priority_queue.pop()\n # Check if goal state is reached\n if problem.isGoalState(node_to_expand):\n break\n next_nodes = problem.getSuccessors(node_to_expand)\n path_to_parent = path_to_node[node_to_expand]\n\n for one_node in next_nodes:\n point, move, cost = one_node\n curr_path = path_to_node[node_to_expand] + [move]\n curr_cost = problem.getCostOfActions(curr_path)\n heuristic_cost = heuristic(point, problem)\n # Check if current node already exists in the previously visited nodes\n if point in path_to_node:\n prev_cost = problem.getCostOfActions(path_to_node[point])\n if prev_cost > curr_cost:\n path_to_node[point] = curr_path\n priority_queue.update(point, curr_cost + heuristic_cost)\n \n else:\n path_to_node[point] = curr_path\n priority_queue.update(point, curr_cost + heuristic_cost)\n \n # current_cost = problem.getCostOfActions(point) * p_c + heuristic(point, problem) * h_c\n\n print(node_to_expand) \n return path_to_node[node_to_expand]\n \n# nodes_to_expand = set()\n# # get max value node in the fringe node\n# min_val = float(\"inf\")\n# for one_node in fringe_node:\n# # Compute the cost to reach a node\n# total_cost = cost_to_point[one_node] * p_c + heuristic(one_node,problem) * h_c\n# if total_cost < min_val:\n# min_val = total_cost\n# \n# for one_node in fringe_node:\n# # Compute the cost to reach a node\n# total_cost = cost_to_point[one_node] * p_c + heuristic(one_node,problem) * h_c\n# if total_cost == min_val:\n# nodes_to_expand.add(one_node)\n# fringe_node.remove(one_node)\n#\n# # Expand the fringe node \n# for one_node in nodes_to_expand:\n# path_to_parent = path_to_point[one_node]\n# for nxt_node in problem.getSuccessors(one_node):\n# pos = nxt_node[0]\n# mv = nxt_node[1]\n# # check if point already present in path to point\n# prev_cost = float(\"inf\")\n# if pos in cost_to_point:\n# prev_cost = cost_to_point[pos]\n# new_path = path_to_parent + [mv]\n# if prev_cost > problem.getCostOfActions(new_path):\n# path_to_point[pos] = new_path\n# cost_to_point[pos] = problem.getCostOfActions(new_path)\n# fringe_node.append(pos)\n#\n# # Check if destination is reached in the fringe node\n# for one_node in fringe_node:\n# if problem.isGoalState(one_node):\n# final_node = one_node\n# goal_found = True\n# break\n# \n# #print(len(fringe_node))\n# print(final_node)\n# print(path_to_point[final_node])\n# return path_to_point[final_node] \n\n util.raiseNotDefined()","def initial_solution(self):\n cur_node = random.choice(self.nodes) # start from a random node\n solution = [cur_node]\n\n free_nodes = set(self.nodes)\n free_nodes.remove(cur_node)\n while free_nodes:\n next_node = min(free_nodes, key=lambda x: self.dist(cur_node, x)) # nearest neighbour\n free_nodes.remove(next_node)\n solution.append(next_node)\n cur_node = next_node\n\n cur_fit = self.fitness(solution)\n if cur_fit < self.best_fitness: # If best found so far, update best fitness\n self.best_fitness = cur_fit\n self.best_solution = solution\n self.fitness_list.append(cur_fit)\n return solution, cur_fit","def solve(num_wizards, num_constraints, wizards, constraints):\n\n # print(num_wizards)\n # print(num_constraints)\n # print(wizards)\n # print(constraints)\n # node_set = set(wizards)\n \n\n\n def cost(sol,num_constraints,constraints):\n constraints_satisfied = 0\n constraints_failed = []\n output_ordering_map = {k: v for v, k in enumerate(sol)}\n for c in constraints:\n\n m = output_ordering_map # Creating an alias for easy reference\n\n wiz_a = m[c[0]]\n wiz_b = m[c[1]]\n wiz_mid = m[c[2]]\n\n if (wiz_a < wiz_mid < wiz_b) or (wiz_b < wiz_mid < wiz_a):\n constraints_failed.append(c)\n else:\n constraints_satisfied += 1\n return num_constraints - constraints_satisfied\n\n def neighbors(sol):\n wiz1 = random.randint(0,num_wizards-1)\n wiz2 = random.randint(0,num_wizards-1)\n\n new_sol = copy.copy(sol)\n temp = new_sol[wiz1]\n new_sol[wiz1] = new_sol[wiz2]\n new_sol[wiz2] = temp\n \n return new_sol\n\n def acceptance_probability(old_cost,new_cost,T):\n exponent = (old_cost - new_cost) / T\n \n try:\n ans = math.exp(exponent)\n except OverflowError:\n ans = float('inf')\n return ans\n\n\n def anneal(solution, num_constraints, constraints):\n old_cost = 0\n new_cost = 0\n old_cost = cost(solution,num_constraints,constraints)\n T = 1.0\n T_min = 0.000001\n alpha = 0.98\n while T > T_min:\n i = 1\n while i <= 1000:\n new_solution = neighbors(solution)\n new_cost = cost(new_solution,num_constraints,constraints)\n if new_cost == 0:\n return new_solution,new_cost\n ap = acceptance_probability(old_cost, new_cost, T)\n if ap > random.random():\n solution = new_solution\n old_cost = new_cost\n i += 1\n T = T*alpha\n return solution, old_cost\n\n s = copy.copy(wizards)\n random.shuffle(s)\n ret = anneal(s,num_constraints,constraints)\n \n for i in range(10):\n if ret[1] == 0:\n break\n random.shuffle(s)\n new_ret = anneal(s,num_constraints,constraints)\n print(i)\n if new_ret[1] < ret[1]:\n ret = new_ret\n print(\"constraints failed: {0}\".format(ret[1]))\n return ret[0]","def main():\r\n start = input(\"Enter the starting state: \").replace(\" \", \"\") # Remove whitespace from states\r\n goal = input(\"Enter the goal state: \").replace(\" \", \"\")\r\n if validate_input(start, goal) == False:\r\n return print(\"Invalid input.\")\r\n\r\n start_list = [] # Convert into list for efficieny\r\n for i in start:\r\n start_list.append(int(i))\r\n\r\n goal_list = [] # Convert into list for efficieny\r\n for i in goal:\r\n goal_list.append(int(i))\r\n\r\n state_inversions = inversions(start_list)\r\n print(\"\\nStart state inversions:\", state_inversions)\r\n goal_inversions = inversions(goal_list)\r\n print(\"Goal state inversions:\", goal_inversions)\r\n\r\n if state_inversions % 2 != goal_inversions % 2: # If polarity is uneven, not solvable\r\n print(\"Unsolvable configurations.\\nPolarities do not match.\")\r\n exit(1)\r\n\r\n heuristic = -1 # Set heuristic option for A* search\r\n while heuristic != 0 and heuristic != 1:\r\n try:\r\n heuristic = int(input(\"\\nEnter heuristic function: \\n0 for Manhattan\\n1 for Eucledian\\n= \"))\r\n except (EOFError, KeyboardInterrupt):\r\n print('Terminating.')\r\n exit()\r\n except (KeyError, ValueError):\r\n print('Invalid option.')\r\n\r\n start_time = time.time() # Start search time\r\n nodes_searched = astar_search(start_list, goal_list, heuristic)\r\n end_time = time.time() # Stop search timer\r\n\r\n print(\"\\nSolved in: {:.2f}\".format(end_time-start_time), \"seconds\")\r\n print(\"Nodes explored:\", nodes_searched)\r\n exit()","def aStar(sx = 1.55, sy = 2.05, gx = 1.55, gy = 4.05, d_diagnoal = 14, d_straight = 10, grid_reso = 0.1, grid_width = 6, grid_height = 3):\n width = int(grid_width/grid_reso)\n height = int(grid_height/grid_reso)\n #TODO\n A_sx, A_sy = realPosTogridPos(sx, sy, grid_reso = grid_reso)\n A_gx, A_gy = realPosTogridPos(gx, gy, grid_reso = grid_reso)\n startNode = Node(A_sx,A_sy,None,0,0,0)\n goalNode = Node(A_gx,A_gy,None,0,0,0)\n # The set of nodes already evaluated\n closedSet = set()\n # The set of currently discovered nodes that are not evaluated yet.\n openSet = set()\n # Initially, only the start node is known.\n openSet.add(startNode)\n # For each node, which node it can most efficiently be reached from.If a node can be reached from many nodes, cameFrom will eventually contain the most efficient previous step.\n cameFrom = []\n # For each node, the cost of getting from the start node to that node.\n gScore = create_gScore(width, height)\n start_x = startNode.x\n start_y = startNode.y\n # The cost of going from start to start is zero.\n startNode.g_value = 0\n gScore[start_x][start_y] = 0\n # For each node, the total cost of getting from the start node to the goal by passing by that node. That value is partly known, partly heuristic.\n fScore = create_fScore(width, height)\n # For the first node, that value is completely heuristic.\n startNode.f_value = heuristic_cost_estimate(startNode, goalNode,d_diagnoal,d_straight)\n fScore[start_x][start_y] = heuristic_cost_estimate(startNode, goalNode,d_diagnoal,d_straight)\n while len(openSet) != 0:\n # current := the node in openSet having the lowest fScore[] value\n current = node_lowest_fScore(openSet)\n # If it is the item we want, retrace the path and return it\n if current.equal(goalNode):\n path = reconstruct_path(cameFrom, current) # path in real\n # print \"path\",path\n pathInReal = convertGridPathToReal(path, sx, sy, gx, gy, grid_reso = grid_reso) # path in grid\n return pathInReal\n\n openSet.remove(current)\n closedSet.add(current)\n current_neighbors = getNeighbors(current, width, height)\n current_neighbors_num = current_neighbors.shape[1]\n # for neighbor in current_neighbors:\n for index in range(current_neighbors_num):\n [neighbor_x,neighbor_y] = current_neighbors[:,index]\n neighbor = Node(neighbor_x,neighbor_y,None,np.inf,np.inf,np.inf)\n if neighbor_in_closedSet(neighbor,closedSet):\n continue\n if neighbor_not_in_openSet(neighbor,openSet):\t# Discover a new node\n openSet.add(neighbor)\n\n # The distance from start to a neighbor the \"dist_between\" function may vary as per the solution requirements.\n current_x = current.x\n current_y = current.y\n tentative_gScore = gScore[current_x][current_y] + dist_between(current, neighbor,d_diagnoal,d_straight)\n neighbor_x = neighbor.x\n neighbor_y = neighbor.y\n if tentative_gScore >= gScore[neighbor_x][neighbor_y]:\n continue\t\t# This is not a better path.\n\n neighbor.father = current\n cameFrom.append(neighbor)\n gScore[neighbor_x][neighbor_y] = tentative_gScore\n neighbor.g_value = tentative_gScore\n neighbor_f_value = gScore[neighbor_x][neighbor_y] + heuristic_cost_estimate(neighbor, goalNode,d_diagnoal,d_straight)\n fScore[neighbor_x][neighbor_y] = neighbor_f_value\n neighbor.f_value = neighbor_f_value\n return False","def solve(num_wizards, num_constraints, wizards, constraints): \n global wiz_const\n wiz_const = mapConstraints(wizards, constraints)\n partial_soltns = []\n\n # counter for priority queue since it doesn't allow \n # identical priorities\n k = 0\n\n # list of wizards sorted by lowest to highest degree\n sorted_wiz = sortWizByConsts(wiz_const)\n wiz_rankings = {wiz: i for i, wiz in enumerate(sorted_wiz)}\n\n const_set = set(map(tuple, constraints))\n for i in range(4) : \n heapq.heappush(partial_soltns, (0, k, nx.DiGraph(), const_set.copy()))\n k += 1\n\n print(\"setup done, commencing solving\")\n\n while len(partial_soltns) : \n\n # for partial_soltn, const_set in partial_soltns : \n# partial_soltns.remove(partial_soltn)\n num_seen, _, partial_soltn, const_set = heapq.heappop(partial_soltns)\n const = findNextConst(partial_soltn, const_set, wiz_rankings)\n print(\"seen \" + str(len(partial_soltn)) + \"\\t num partial_solutions\\t\" + str(len(partial_soltns)))\n try : \n const_set.remove(const)\n except KeyError : \n print(\"BAD SHIT\")\n pass\n possible_arrangements = [(const[0], const[1], const[2]),\n (const[2], const[0], const[1]), \n (const[2], const[1], const[0]),\n (const[1], const[0], const[2])]\n for arr in possible_arrangements:\n soltn = partial_soltn.copy()\n a, b, c = arr\n if not (soltn.has_node(a) and soltn.has_node(b) and nx.has_path(soltn, a, b)) : \n soltn.add_edge(a, b)\n if not (soltn.has_node(b) and soltn.has_node(c) and nx.has_path(soltn, b, c)) : \n soltn.add_edge(b, c)\n # see if we violated any other constraints (seen or not seen)\n is_valid, num_wiz = validNumWiz(soltn, const_set)\n\n if is_valid and len(list(nx.simple_cycles(soltn))) == 0 :\n heapq.heappush(partial_soltns, (-len(soltn), k, soltn, const_set.copy()))\n k += 1\n # are we done?\n if num_wiz == num_wizards :\n print(\"FINAL SOLUTION (found without processing all constraints but validating against them)\")\n ordering = list(nx.topological_sort(soltn))\n finishEverything(ordering, constraints)\n return ordering\n if foundCompleteOrdering(heapq.heappop(partial_soltns)) : \n print(\"FINAL SOLUTION\")\n ordering = list(nx.topological_sort(soltn))\n finishEverything(ordering, constraints)\n return ordering\n print(\"NO SOLUTION FOUND\")\n return \"\"","def solve_tour(self):\n\t\tboard = [[-1 for _ in range(self.N)]for _ in range(self.N)]\n\t\tboard[0][0] = 0\n\n\t\tz = self.find_tour(board, 0, 0, 1)\n\t\tif z:\n\t\t\tfor i in range(self.N):\n\t\t\t\tfor j in range(self.N):\n\t\t\t\t\tself.solution.append(board[i][j])\n\t\t\tprint board\n\t\t\treturn self.solution\n\t\t\t\t\n\t\telse:\n\t\t\tprint(\"No solution\")","def aStarSearch(problem, heuristic=myHeuristic):\n\n #frontier = util.PriorityQueue()\n #startState = problem.getStartState()\n #startNode = (startState, ['East'], 0)\n #frontier.push(startNode, 0)\n\n #currentState, actions, currentCost = frontier.pop()\n #return ['West','West', 'West','West','South','South','East', 'South','South','West','West']\n\n fronteira = util.PriorityQueue()\n\n nohExplorado = [] #(state, cost)\n\n startState = problem.getStartState()\n nohInicial = (startState, [], 0) #(state, action, cost)\n\n fronteira.push(nohInicial, 0)\n\n while not fronteira.isEmpty():\n\n #pega o Noh de menor \"custo\" na fila\n curEstado, todasAcoes, curCusto = fronteira.pop()\n\n #Coloca Noh atual na lista de explorados\n nohAtual = (curEstado, curCusto)\n nohExplorado.append((curEstado, curCusto))\n\n if problem.isGoalState(curEstado):\n #print(todasAcoes)\n return todasAcoes\n\n else:\n #Lista de Sucessores (successor, action, stepCost) e examina cada um\n sucessores = problem.getSuccessors(curEstado)\n for sucEstado, sucAcao, sucCusto in sucessores:\n novaAcao = todasAcoes + [sucAcao]\n novoCusto = problem.getCostOfActions(novaAcao)\n novoNoh = (sucEstado, novaAcao, novoCusto)\n\n #Checa se o sucessor jah foi visitado\n jah_foi_explorado = False\n for explorado in nohExplorado:\n exEstado, exCusto = explorado\n if (sucEstado == exEstado) and (novoCusto >= exCusto):\n jah_foi_explorado = True\n\n #Se nao foi explorado, coloca na fronteira\n if not jah_foi_explorado:\n fronteira.push(novoNoh, novoCusto + heuristic(sucEstado, problem))\n\n\n return todasAcoes","def solve(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix, params=[]):\n\n loc_map = {}\n drop_off_dict = {}\n num_home_visited = 0\n\n \"\"\"\n for i in range(len(list_of_locations)):\n loc_map[i] = list_of_locations[0]\n \"\"\"\n\n home_indexes = convert_locations_to_indices(list_of_homes, list_of_locations)\n start = list_of_locations.index(starting_car_location)\n graph, msg = adjacency_matrix_to_graph(adjacency_matrix)\n num_homes = len(list_of_homes)\n\n car_path = []\n all_paths = dict(nx.all_pairs_dijkstra(graph))\n visited = set()\n\n #print(start)\n car_path.append(start)\n current_node = start\n\n if start in home_indexes:\n visited.add(start)\n drop_off_dict[start] = [start]\n num_home_visited += 1\n\n while num_home_visited < num_homes:\n dist_dict = all_paths.get(current_node)[0]\n paths_dict = all_paths.get(current_node)[1]\n\n dist_dict = {k:v for (k,v) in dist_dict.items() if k not in visited and k in home_indexes}\n min_dist = min(dist_dict.values())\n min_list = [k for k in dist_dict.keys() if dist_dict[k] <= min_dist]\n #print(dist_dict.values())\n target = min_list[0]\n drop_off_dict[target] = [target]\n #print(target+1)\n #print(target)\n car_path.pop()\n car_path.extend(paths_dict[target])\n\n visited.add(target)\n current_node = target\n num_home_visited += 1\n\n paths_dict = all_paths.get(current_node)[1]\n car_path.pop()\n car_path.extend(paths_dict[start])\n #print((drop_off_dict.keys()))\n #car_path = [start, ...., start]\n #drop_off_dict = {drop_off_loc: [home1, home2, ...] }\n\n return car_path, drop_off_dict","def generate_initial_solution(self, nr_iterations=2000, use_seed=False, seed=1):\n\n best_route = None\n best_score = float('inf')\n\n for i in range(nr_iterations):\n route = Route(self.jobs, self.stores, self.deliverers, self.distances_matrix, self.evaluator)\n if use_seed:\n route.generate_initial_route(seed=seed, initialization_method=self.route_initialization_method )\n else:\n route.generate_initial_route(seed=i, initialization_method=self.route_initialization_method )\n\n route_score = route.evaluate()\n if route_score < best_score:\n best_score = route_score\n best_route = route\n # assert best_route == None\n self.solution = best_route\n return best_score, best_route","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 astar(grid, heuristic):\r\n\r\n print (grid.getStart())\r\n frontier = PriorityQueue()\r\n frontierCpy = {}\r\n\r\n goal = grid.getGoals()[0]\r\n\r\n startX = grid.getStart()[0]\r\n startY = grid.getStart()[1]\r\n startNode = Node(((startX, startY), 0), None)\r\n\r\n init_heu = heuristic(startNode.cell[0], goal)\r\n frontierCpy[startNode.cell[0]] = init_heu\r\n frontier.put((init_heu, 0, startNode))\r\n\r\n while frontier.qsize() != 0:\r\n tup = frontier.get()\r\n\r\n currNode = tup[2]\r\n currG = tup[1] * -1\r\n grid.addVisited(currNode.cell[0])\r\n frontierCpy.pop(currNode.cell[0], None)\r\n\r\n if currNode.cell[0] == goal:\r\n path = []\r\n while currNode != None:\r\n path.insert(0, currNode.cell[0])\r\n currNode = currNode.parent\r\n grid.setPath(path)\r\n return path\r\n\r\n\r\n neighbors = grid.getNeighbors(currNode.cell[0])\r\n\r\n for n in neighbors:\r\n if n[0] not in grid.getVisited():\r\n newNode = Node(n, currNode)\r\n\r\n h = heuristic(n[0], goal)\r\n\r\n oneStepCost = n[1]\r\n g = oneStepCost + currG\r\n if n[0] not in frontierCpy or frontierCpy[n[0]] > h + g:\r\n frontier.put((h+g, -1*g, newNode))\r\n frontierCpy[n[0]] = h+g\r\n print(\"CANT FIND A PATH\")","def improve(self):\n tour = Tour(self.heuristic_path)\n\n # Find all valid 2-opt moves and try them\n for t1 in self.heuristic_path:\n around = tour.around(t1)\n\n for t2 in around:\n broken = set([makePair(t1, t2)])\n # Initial savings\n gain = TSP.dist(t1, t2)\n\n close = self.closest(t2, tour, gain, broken, set())\n\n # Number of neighbours to try\n tries = 5\n\n for t3, (_, Gi) in close:\n # Make sure that the new node is none of t_1's neighbours\n # so it does not belong to the tour.\n if t3 in around:\n continue\n\n joined = set([makePair(t2, t3)])\n\n # The positive Gi is taken care of by `closest()`\n Log.debug(\"Start: X: {} - Y: {} = {}\".format((t1, t2),\n (t2, t3), Gi))\n\n if self.chooseX(tour, t1, t3, Gi, broken, joined):\n # Return to Step 2, that is the initial loop\n return True\n # Else try the other options\n\n tries -= 1\n # Explored enough nodes, change t_2\n if tries == 0:\n break\n\n return False","def a_star_planning(start_x, start_y, goal_x, goal_y, id):\n # extract the index of start node, goal node and obstacles\n start = Point(round(start_x/grid_size), round(start_y/grid_size), 0.0, -1, [0,0,0])\n goal = Point(round(goal_x/grid_size), round(goal_y/grid_size), 0.0, -1, [0,0,0])\n if not_legal(goal, id):\n print ('not a legal goal')\n return False\n \n # time.sleep(10)\n\n # create the open list and close list to store nodes\n openset, closeset = deque(), deque()\n openset.append(start)\n\n while True:\n # find out the min f node to explore\n\n current_node = min(openset,\n key=lambda node: node.g + calculate_heuristic(node,goal))\n\n # pltplt.plot(current_node.x, current_node.y, \"b*\")\n if len(closeset) % 10 == 0:\n plt.pause(0.001)\n\n if current_node.x == goal.x and current_node.y == goal.y:\n print(\"Congratulations! You have found the goal!\")\n goal.parent = current_node\n break\n\n # Remove it from the open list\n openset.remove(current_node)\n # Add it to the close list\n closeset.append(current_node)\n\n # Explore the neighbour\n for motion in motions:\n if motion == current_node.parent_motion:\n turn_cost = 0\n elif (motion[0] == -1 * current_node.parent_motion[0]) and (motion[1] == -1 * current_node.parent_motion[1]):\n turn_cost = 1.5\n else:\n turn_cost = 1\n\n node = Point(current_node.x + motion[0],\n current_node.y + motion[1],\n current_node.g + motion[2] + turn_cost,\n current_node,\n motion,\n )\n\n # ignore it if it is in the close list\n flag = False\n for item in closeset:\n if item.x == node.x and item.y == node.y:\n flag = True\n break\n if flag:\n continue\n # ignore it if it is obstacle\n\n if not_legal(node, id):\n continue\n # update its parent if it is the open list\n flag = True\n for item in openset:\n if item.x == node.x and item.y == node.y:\n flag = False\n # if closer, update the parent\n if node.g <= item.g:\n item.g = node.g\n item.parent = node.parent\n item.parent_motion = node.parent_motion\n break\n # add to the open list if it is not in the open list\n if flag:\n openset.append(node)\n\n # generate the final path\n while True:\n route = deque()\n route.append(goal)\n plt.plot(goal.x, goal.y, \"rx\")\n if goal.parent == -1:\n break\n else:\n goal = goal.parent\n route.appendleft(goal)\n # return route\n # return False\n if NEED_DRAW:\n # draw map\n for i in range(map.gridwidth):\n for j in range(map.gridheight):\n if map.grid[1,i,j] >0:\n plt.plot(i, j, \"xc\")\n\n plt.plot(start.x, start.y, \"ro\")\n plt.plot(goal.x, goal.y, \"go\")\n\n for goal in route:\n plt.plot(goal.x, goal.y, \"rx\")\n plt.show()","def foodHeuristic(state, problem):\n position, foodGrid = state\n \"*** YOUR CODE HERE ***\"\n \"\"\"\n Mi heurística consiste en hacer simplemente el máximo de las distancias reales del state a cada nodo con comida\n He provado diferentes heurísticas y esta es la que me expande menos nodos, aunque no es la más óptima temporalmente\n Tardé mucho tiempo en darme cuenta de que había una función que calculaba la distancia real entre dos nodos\n NOTA: NO EJECUTAR CON LABERINTOS MÁS GRANDES QUE EL tinySearch. El algoritmo requiere muchísimo tiempo\n \"\"\"\n max = 0 # Inicializo el máximo en 0\n for food in foodGrid.asList(): # Esto me da cada food como un nodo (x,y), pero sólo los nodos que tengan comida\n distance = mazeDistance(position, food, problem.startingGameState) # Distancia real del state a una comida\n if max < distance: # Cálculo del máximo\n max = distance\n return max\n\n # La siguiente heurística también servía, y de hecho tardaba mucho menos, pero el autograder me daba 2/4\n # ya que se expandían más de 12.000 nodos.\n # return len(foodGrid.asList())","def a_star(start: Vector2D, goal: Vector2D, grid: Scene, heuristic: Callable[[Vector2D, Vector2D], float]) -> (list, list):\n\n\n frontier = PriorityQueue() # nodes to be explored\n expected_cost = heuristic(start, goal) # estimate of cost to reach goal from current node\n\n prev_node = dict() # maps n to node that precedes it in cheapest currently-known path from start to n\n cost_so_far = dict() # maps n to cost of cheapest currently-known path from start to n\n explored = [] # keeps track of previously explored nodes, to be drawn later\n\n frontier.put(start, expected_cost, expected_cost)\n prev_node[start] = None\n cost_so_far[start] = 0\n\n while not frontier.empty():\n current = frontier.get()\n\n if current == goal: # solution found!\n return (reconstruct_path(goal, prev_node), explored)\n\n explored.append(current)\n\n for neighbor in grid.get_unexplored_neighbors(current):\n path_cost = cost_so_far[current] + grid.cost(neighbor) # cost of path to 'neighbor' going through 'current'\n\n if (neighbor not in cost_so_far) or (path_cost < cost_so_far[neighbor]): # if this path reaches node 'neighbor' faster than some previous path\n cost_so_far[neighbor] = path_cost\n expected_cost = heuristic(neighbor, goal)\n priority = path_cost + expected_cost\n frontier.put(neighbor, priority, expected_cost) # 'expected_cost' is used as a tie breaker to reduce paths to explore\n\n prev_node[neighbor] = current\n\n # If frontier empty but goal was never reached, no solution was found\n return ([], explored)","def aStarSearch(problem, heuristic=nullHeuristic):\n visited = []\n solution = []\n intialCost = 0\n priorityQueue = util.PriorityQueue()\n priorityQueue.push((problem.getStartState(),solution,intialCost),intialCost)\n \n while not priorityQueue.isEmpty():\n coord, solution, totalStep = priorityQueue.pop()\n if problem.isGoalState(coord):\n return solution\n if not coord in visited:\n visited+=[coord]\n for position, direction, step in problem.getSuccessors(coord):\n newSolution = solution+[direction]\n g = totalStep + step\n newTotalCost = g + heuristic(position, problem)\n priorityQueue.push((position, newSolution, g), newTotalCost)","def Find_Path(self):\n closed_nodes_map = [] # map of closed (tried-out) nodes\n open_nodes_map = [] # map of open (not-yet-tried) nodes\n dir_map = [] # map of directions\n row = [0] * self.n\n for i in range(self.m): # create 2d arrays\n closed_nodes_map.append(list(row))\n open_nodes_map.append(list(row))\n dir_map.append(list(row))\n \n pq = [[], []] # priority queues of open (not-yet-tried) nodes\n pqi = 0 # priority queue index\n # create the start node and push into list of open nodes\n n0 = node(self.xStart, self.yStart, 0.0, 0.0)\n n0.updatePriority(self.xFinish, self.yFinish)\n heappush(pq[pqi], n0)\n open_nodes_map[self.yStart][self.xStart] = n0.priority # mark it on the open nodes map\n \n # A* search\n while len(pq[pqi]) > 0:\n # get the current node w/ the highest priority\n # from the list of open nodes\n n1 = pq[pqi][0] # top node\n n0 = node(n1.xPos, n1.yPos, n1.distance, n1.priority)\n x = n0.xPos\n y = n0.yPos\n heappop(pq[pqi]) # remove the node from the open list\n open_nodes_map[y][x] = 0\n # mark it on the closed nodes map\n closed_nodes_map[y][x] = 1\n \n # quit searching when the goal state is reached\n if x == self.xFinish and y == self.yFinish:\n # Generate the path from finish to start by following the \n # directions.\n return self.Reconstruct_Path(dir_map)\n \n # generate moves (child nodes) in all possible directions\n for i in range(self.num_directions):\n new_x = x + self.dx[i]\n new_y = y + self.dy[i]\n Flag=True\n if not (new_x < 0 or new_x > self.n-1 or new_y < 0 or new_y > self.m - 1\n or self.MAP[new_y][new_x] == 1 or closed_nodes_map[new_y][new_x] == 1):\n # Check to see if the extended path runs through any obstacles\n if (abs(self.dx[i])>1 or abs(self.dy[i])>1):\n # Need to check that the path does not pass an object\n JumpCells=2*max(abs(self.dx[i]),abs(self.dy[i]))-1\n for K in range(1,JumpCells):\n YPOS=int(round(K*1.0*self.dy[i]/JumpCells))\n XPOS=int(round(K*1.0*self.dx[i]/JumpCells))\n if (self.MAP[y+YPOS][x+XPOS]==1):\n Flag=False\n if Flag: \n # generate a child node\n m0 = node(new_x, new_y, n0.distance, n0.priority)\n m0.calc_cost(self.dx[i], self.dy[i])\n m0.updatePriority(self.xFinish, self.yFinish)\n # if it is not in the open list then add into that\n if open_nodes_map[new_y][new_x] == 0:\n open_nodes_map[new_y][new_x] = m0.priority\n heappush(pq[pqi], m0)\n # mark its parent node direction\n dir_map[new_y][new_x] = (self.num_directions-i-1) % self.num_directions\n elif open_nodes_map[new_y][new_x] > m0.priority:\n # update the priority info\n open_nodes_map[new_y][new_x] = m0.priority\n # update the parent direction info\n dir_map[new_y][new_x] = (self.num_directions-i-1) % self.num_directions\n # replace the node\n # by emptying one pq to the other one\n # except the node to be replaced will be ignored\n # and the new node will be pushed in instead\n while not (pq[pqi][0].xPos == new_x and pq[pqi][0].yPos == new_y):\n heappush(pq[1 - pqi], pq[pqi][0])\n heappop(pq[pqi])\n heappop(pq[pqi]) # remove the wanted node\n # empty the larger size pq to the smaller one\n if len(pq[pqi]) > len(pq[1 - pqi]):\n pqi = 1 - pqi\n while len(pq[pqi]) > 0:\n heappush(pq[1-pqi], pq[pqi][0])\n heappop(pq[pqi]) \n pqi = 1 - pqi\n heappush(pq[pqi], m0) # add the better node instead\n return '','' # no route found","def astar(grid, heuristic):\r\n\r\n class MapNode:\r\n def __init__(self, cell, cost, parent):\r\n self.cell = cell\r\n self.cost = cost\r\n self.parent = parent\r\n\r\n @functools.total_ordering\r\n class FrontierElement:\r\n def __init__(self, cell, cost, parent, estimatedCost):\r\n self.node = MapNode(cell, cost, parent)\r\n self.estimatedCost = estimatedCost\r\n def __lt__(self, other):\r\n return self.estimatedCost < other.estimatedCost\r\n def __eq__(self, other):\r\n return self.estimatedCost is other.estimatedCost\r\n\r\n frontier = PriorityQueue()\r\n visitedNodes = set()\r\n frontier.put(FrontierElement(grid.getStart(), 0, None, 0))\r\n\r\n path = []\r\n\r\n while not frontier.empty():\r\n currentElement = frontier.get()\r\n grid.addVisited(currentElement.node.cell)\r\n visitedNodes.add(currentElement.node.cell)\r\n\r\n if currentElement.node.cell in grid.getGoals():\r\n currentNode = currentElement.node\r\n while currentNode is not None:\r\n path.insert(0, currentNode.cell)\r\n currentNode = currentNode.parent\r\n break\r\n\r\n for neighbor in grid.getNeighbors(currentElement.node.cell):\r\n neighborCoord = neighbor[0]\r\n\r\n if neighborCoord in visitedNodes:\r\n continue\r\n\r\n neighborCost = neighbor[1]\r\n cheapestGoal = min(grid.getGoals(), key=lambda goal: Vector2.fromCell(neighborCoord).squaredDistanceTo(Vector2.fromCell(goal)))\r\n\r\n cost = currentElement.node.cost + neighborCost\r\n\r\n frontier.put(FrontierElement(neighborCoord, cost, currentElement.node, cost + heuristic(neighborCoord, cheapestGoal)))\r\n\r\n grid.setPath(path)","def solve_environment(self):\n \n #The first problem formulation\n #K kinds of towers\n #See more details about problem formulation in the writeup \n \n #Get a full matrix of the concatenated coverage matrices for \n #each tower type. THis new matrix has dimensions:\n #(Ntowers) x (sum(potential sites)), where the sum o=is over all tower types\n coverage = np.hstack(i for i in self.coverage_matrices)\n print coverage\n print coverage.shape \n \n #Diagonal matrix of the values of each target\n #(for the scenarios where we don't care about maximizing covered value,\n #target_values is just all ones, so this is just the identity matrix)\n V = np.diag(self.target_values)\n \n #If doing scenario where we want to fortify weakest link, only makes\n #sense if all targets are equal value:\n if self.objective_type == 'min_entries':\n V = np.eye(len(self.target_values))\n\n #Get the matrix of coverage values / expected value saved:\n C = np.dot(V,coverage)\n print 'V', V\n print 'coverage', coverage\n print 'C', C\n \n \n #Since not gauranteed to reach global optimum on any particular initialization,\n #run a few times and take the best result.\n #Just define \"best result\" as the result which had the most overall \n #\"converged\" x, combined over all tower kinds. \n# for j in xrange(self.N_random_starts_max):\n \n \n a = 2. #1.\n tau = 1e-4\n N = sum(i for i in self.N_tower_sites)\n w = np.zeros(N)\n ones = np.ones(N)\n p = 1. #the exponents power when doing he exponent method:\n \n for i in xrange(self.N_reweighting_iterations_max):\n #The concatenated vector of occupancies: Concatenated over all\n #of the kinds of towers.\n x = cvx.Variable(N)\n \n #Different objective functions depending on which optimization problem.\n #These are defined in the scenarios in the main function.\n if self.objective_type == 'min_entries':\n operation = cvx.min_entries\n elif self.objective_type == 'sum_entries':\n operation = cvx.sum_entries\n else:\n raise Exception('must specify valid objective_type')\n \n #Objective function includes penalty term for non-binary x values\n if self.penalty_type == 'reweighted_L1':\n #objective = cvx.Maximize(t - x.T*w)\n objective = cvx.Maximize(operation(C*x - x.T*w))\n\n\n #Main constraints on 0<=x<=1\n constraints = [0<=x, x<=1]\n \n \n #And then for each kind of tower, append the constraint that there\n #be exactly N_i towers, or <= quota (depending on constraint type)\n if self.constraints__type == 'fixed_N_towers' or self.constraints__type == 'tower_quotas':\n for tk in xrange(self.N_tower_kinds):\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\n print before_sum\n print before_sum + self.N_tower_sites[tk]\n if self.constraints__type == 'fixed_N_towers':\n constraints.append(cvx.sum_entries(\n x[before_sum : before_sum + self.N_tower_sites[tk]]\n )==self.N_towers[tk])\n elif self.constraints__type == 'tower_quotas':\n constraints.append(cvx.sum_entries(\n x[before_sum : before_sum + self.N_tower_sites[tk]]\n )<=self.budget__tower_quotas[tk])\n print x[before_sum : before_sum + self.N_tower_sites[tk]]\n \n elif self.constraints__type == 'total_cost':\n costs = np.hstack([np.repeat(self.budget__tower_unit_costs[tk],self.N_tower_sites[tk]) for tk in xrange(self.N_tower_kinds)])\n constraints.append(cvx.sum_entries(costs * x) <= self.budget__total_cost) \n \n \n \n\n\n \n \n print 'penalty_type', self.penalty_type\n print 'objective_type', self.objective_type\n print 'constraints__type', self.constraints__type\n print 'budget__tower_quotas', self.budget__tower_quotas\n print 'operation', operation\n print 'objective', objective\n print 'constraints', constraints\n cvx.Problem(objective, constraints).solve(verbose=self.VERBOSE)\n x = np.array(x.value).flatten()\n print 'x', x\n w = a/(tau+np.abs(x))\n p += 1.\n plt.figure(figsize=(5,5))\n plt.plot(x,marker='o')\n plt.savefig('histrograms_{}.png'.format(i))\n print \n \n \n \n \n #From the solution x, get the coordinates of those tower sites where we\n #really do want to place a tower\n #use = np.isclose(x,1.)\n for tk in xrange(self.N_tower_kinds):\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\n y = x[before_sum : before_sum + self.N_tower_sites[tk]]\n inds = np.argsort(y)\n s = y[inds]\n use = np.where(s>.5)[0]\n print inds\n print s\n print use \n if self.constraints__type == 'fixed_N_towers':\n if len(use) != self.N_towers[tk]:\n print 'Solution did not converge properly. Choosing the K best towers.'\n print self.N_towers[tk], len(use)\n # use = use[-self.N_towers[tk]:]\n use = inds[-self.N_towers[tk]:]\n elif self.constraints__type == 'tower_quotas':\n pass #Just use the towers thresholded at > .5\n print use\n \n \n self.coordinates__solved_towers.append([self.coordinates__tower_sites[tk][mm] for mm in inds[use]])","def astar(grid, heuristic):\r\n evaluatedMap = {}\r\n unevaluatedMap = {}\r\n start = grid.getStart()\r\n goal = grid.getGoals()[0]\r\n startG = 0\r\n startH = heuristic(start,goal)\r\n currentNode = Node(start,startH,startG)\r\n unevaluatedMap[currentNode.coord] = currentNode\r\n \r\n while len(unevaluatedMap) > 0:\r\n # I tried using a PriorityQueue but because a node could end up with \r\n # an updated priority it really didn't make sense to use one and\r\n # instead had to just serach the dictionary each time for the smallest\r\n # priority which is the sum of g and h\r\n currentNode = min(unevaluatedMap.values(),key=lambda x:x.g + x.h)\r\n \r\n # if the current node is the goal then create the path by iterating backwards\r\n # and pushing the current node to the front of the path and then moving to the\r\n # parent node\r\n if currentNode.coord == goal:\r\n path = []\r\n while currentNode.parentNode:\r\n path.insert(0,currentNode.coord)\r\n currentNode = currentNode.parentNode\r\n path.insert(0,currentNode.coord)\r\n grid.setPath(path)\r\n return\r\n \r\n # Move the current node to the evaluated map and delete it from\r\n # the unevaluated map\r\n evaluatedMap[currentNode.coord] = currentNode\r\n del unevaluatedMap[currentNode.coord]\r\n \r\n # Mark the current node as having been visited\r\n grid.addVisited(currentNode.coord)\r\n \r\n # Get the neighbors of the current node\r\n neighbors = grid.getNeighbors(currentNode.coord)\r\n\r\n # For each neighbor check if that neighbor has alread been evaluated\r\n # if it has then skip that neighbor. If it hasn't and it isn't in the\r\n # unevaluated map add it with a high cost and heuristic.\r\n # Get the neighbor from the unevaluated map and calculate the current\r\n # cost. If the current cost is less than what existed update the neighbor\r\n # and add it back to the list otherwise skip to next neighbor\r\n for neighbor in neighbors:\r\n ncoord = (neighbor[0])\r\n if (ncoord) in evaluatedMap:\r\n continue\r\n if (ncoord) not in unevaluatedMap:\r\n node = Node(ncoord,float('inf'),float('inf'))\r\n unevaluatedMap[ncoord] = node\r\n \r\n node = unevaluatedMap[ncoord]\r\n calc_cost = currentNode.g + neighbor[1]\r\n if calc_cost >= node.g:\r\n continue\r\n \r\n node.parentNode = currentNode\r\n node.g = calc_cost\r\n node.h = heuristic(ncoord,goal)","def initialisationTurn(mazeWidth, mazeHeight, mazeMap, preparationTime, turnTime, playerLocation, opponentLocation, coins) :\n global route_table, packages, best_weight, best_path, route\n fill_packages(coins)\n current_package = packages.pop(0)\n exhaustive(current_package, playerLocation, [], 0, (route_table,dists))\n api.debug(best_path)","def spotlessroomba_second_heuristic(state : SpotlessRoombaState) -> float:\n # TODO a nontrivial consistent heuristic\n \n if not state.dirty_locations:\n return 0\n \n best_start = 0 # best dirty tile to start from\n best_cost = INF # cost of the path from the above start tile\n\n for i in range(len(state.dirty_locations)):\n estimate_cost = 0\n lowest_cost = INF\n closest_dirty = 0\n dirty_locations = list(state.dirty_locations)\n current_pos = dirty_locations.pop(i)\n\n # find the shortest cost solution path from this starting tile\n while dirty_locations:\n for j in range(len(dirty_locations)):\n manhattan = abs(current_pos.row - dirty_locations[j].row) + abs(current_pos.col - dirty_locations[j].col)\n if manhattan < lowest_cost:\n lowest_cost = manhattan\n closest_dirty = j\n estimate_cost += lowest_cost\n current_pos = dirty_locations.pop(closest_dirty)\n lowest_cost = INF\n # if estimated path cost is cheaper than best path cost so far, replace best_cost and best_start\n if estimate_cost < best_cost:\n best_cost = estimate_cost\n best_start = i\n # if estimated path cost and best path cost so far are equal, tiebreak with proximity to start tile\n if estimate_cost == best_cost:\n current_pos = state.position\n dist_to_prev_best = abs(current_pos.row - state.dirty_locations[best_start].row) + abs(current_pos.col - state.dirty_locations[best_start].col)\n dist_to_i = abs(current_pos.row - state.dirty_locations[i].row) + abs(current_pos.col - state.dirty_locations[i].col)\n if dist_to_i < dist_to_prev_best:\n best_start = i\n \n\n current_pos = state.position\n # Calculate distance to the best start tile\n dist_to_start = abs(current_pos.row - state.dirty_locations[best_start].row) + abs(current_pos.col - state.dirty_locations[best_start].col)\n # Returned heuristic is the sum of distance to the start tile and estimated cost from said tile\n return dist_to_start + best_cost","def get_pathologic_covering_routes(n_pl, n_target, attacker_strategy, target_values):\n # computes the coefficient used by the greedy oracle to choose routes\n targets_coeff = np.transpose(np.multiply(attacker_strategy, target_values))\n\n # randomly selects the player for which the non optimal choice will be made\n wrong_pl = randint(1, n_pl)\n\n # generate the non optimal route randomly\n n_covered_targets = randint(n_pl,n_target-1)\n non_opt_action = np.zeros(n_target)\n for i in range(0, n_covered_targets):\n random_covered_target = randint(0, n_target-1)\n non_opt_action[random_covered_target] = 1\n\n # compute the value of the non optimal route\n non_opt_val = get_value_single_route(non_opt_action, targets_coeff)\n\n # generate routes that have, as a single, values smaller than the best greedy route but taken togher perform\n # at least as well. [[0,1,...],[...],...] a[r][t]=1 iff t is covered by r.\n # The returned list should have n_pl - 1 routes\n opt_routes = get_opt_routes(n_pl, non_opt_action)\n\n I={}\n for pl in range(1, n_pl+1):\n\n n_r = randint(0, MAX_ROUTES)\n temp = lil_matrix((n_r+1, n_target), dtype='int8')\n\n if pl == wrong_pl:\n # put the non opt route in the bucket\n for t in non_opt_action.nonzero():\n temp[0,t] = 1\n else:\n for t in opt_routes.pop().nonzero():\n temp[0,t] = 1\n\n # generate other random routes with single value less than the non_opt_value\n for r in range(1, n_r):\n new_route = get_r_limited_val(non_opt_val, targets_coeff)\n\n for t in new_route.nonzero():\n temp[r,t] = 1\n\n I[pl] = temp.tocsr()\n\n return I","def shortJourney(Alist,s,d):\n \"\"\"Find shortest distances to s in weighted graph, G\"\"\"\n \n #Initialize dictionaries\n dinit = 10**6\n Edict = {} #Explored nodes\n Udict = {} #Unexplored nodes\n path = [[] for l in Alist]\n\n Alen = len(Alist) #length of Alist\n dinits = [dinit]*Alen #list of airport indexes\n Udict = dict(zip(list(range(Alen)),dinits)) #zip into dictionary\n Udict[s] = 0\n path[s] = [s]\n \n #Main search\n while len(Udict)>0:\n #Find node with min d in Udict and move to Edict\n dmin = dinit\n for n,w in Udict.items():\n if w<dmin:\n dmin=w\n nmin=n\n Edict[nmin] = Udict.pop(nmin)\n print(\"moved node\", nmin)\n\n #Update provisional distances for unexplored neighbors of nmin \n for item in Alist[nmin]: #nminth element is a list of two element tuples (node, weight)\n n = item[0] #first elt of tuple is node/neighbour\n w = item[1] #2nd elt is density/weigh\n #for n,w in etc_______________________-\n \n if n in Edict:\n pass\n elif n in Udict:\n #key difference below\n dcomp = (w+dmin) #take sum as you go along\n if dcomp<Udict[n]:\n print(Udict)\n Udict[n]=dcomp\n path[n] = path[nmin] + [n]\n print(path) \n if nmin == d: #if current node is destination\n return [path[d],Edict[d]]\n return [] #no path","def original_solution():\n matrix = get_data()\n # Construct Graph\n G = nx.DiGraph()\n rows, cols = len(matrix), len(matrix[0])\n for r in xrange(rows):\n for c in xrange(cols):\n if 0 < c:\n G.add_edge(r*cols + c, r*cols + c - 1, weight=matrix[r][c-1])\n if c < cols-1:\n G.add_edge(r*cols + c, r*cols + c + 1, weight=matrix[r][c+1])\n if 0 < r:\n G.add_edge(r*cols + c, (r-1)*cols + c, weight=matrix[r-1][c])\n if r < rows-1:\n G.add_edge(r*cols + c, (r+1)*cols + c, weight=matrix[r+1][c])\n # Calculate shortest path\n path = nx.shortest_path(G, 0, rows*cols-1, weighted=True)\n \n # Get cost for path\n s = 0\n for p in path:\n c = p % cols\n r = (p - c) / rows\n s += matrix[r][c]\n return s","def greedy_selector(self):\n r_k = 0 \n best_route = []\n cities_to_visit = [i for i in range(1, self.city_count)]\n for _ in range(1, self.city_count):\n s_ind = np.argmax([self.tau[(r_k, u)] for u in cities_to_visit])\n s_k = cities_to_visit.pop(s_ind)\n best_route.append((r_k, s_k))\n r_k = s_k\n best_route.append((r_k, 0))\n \n shortest_path = np.sum([self.phi[(p)] for p in best_route])\n return best_route, shortest_path","def aStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE ***\"\n\n #Creamos las estructuras de datos necesarias (priority queue y set)\n openNodes = util.PriorityQueue()\n closedNodes = set([])\n\n #Guardamos el nodo inicial\n node = Node(problem.getStartState(), '', 0, None)\n\n #Calculamos funcion heuristica y el coste acumulado para sacar la funcion de evaluacion del nodo inicial\n fn = problem.getCostOfActions(node.path) + heuristic(node.name, problem);\n\n #Lo metemos en la cola con su funcion de evaluacion como prioridad\n openNodes.push(node, fn)\n\n #Iteramos para cada nodo\n while True:\n if openNodes.isEmpty():\n break #ERROR: throw exception\n else :\n #sacamos el nodo de arriba de la cola\n node = openNodes.pop()\n if problem.isGoalState(node.name): #Comprobamos si el nodo es Goal. Si lo es terminamos.\n break\n else: #Expandimos los nodos sucesores del nodo si no estan en closed\n if nodeIsClosed(node, closedNodes) is False:\n for successor in problem.getSuccessors(node.name):\n n, p, c = successor\n succNode = Node(n, p, c, node)\n if nodeIsClosed(succNode, closedNodes) is False:\n fn = problem.getCostOfActions(findPath(succNode)) + heuristic(succNode.name, problem);\n openNodes.push(succNode, fn)\n #Metemos el nodo en closed\n closedNodes.add(node)\n\n #Devolvemos el camino al Goal\n return findPath(node)","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 a_star(self, start, final):\n self.speed_setting_season()\n cost_so_far = {}\n frontier = PriorityQueue()\n parents = {}\n frontier.put(start, 0)\n cost_so_far[start] = 0\n f_value = {}\n f_value[start] = self.grid.heuristic(start[0], start[1], final[0], final[1])\n final_path_list = []\n while not frontier.empty():\n actual_node = frontier.get()\n final_path_list = []\n if actual_node == final:\n curr = final\n while curr != start:\n final_path_list.insert(0, curr)\n curr = parents[curr]\n final_path_list.insert(0, start)\n break\n potential_neighbors = self.grid.neighbors(int(actual_node[0]), int(actual_node[1]))\n for neighbor in potential_neighbors:\n g_value = cost_so_far[actual_node] + self.grid.cost_g(actual_node[0], actual_node[1],\n neighbor[0],\n neighbor[1])\n h_value = self.grid.heuristic(neighbor[0], neighbor[1], final[0], final[1])\n if neighbor not in cost_so_far or g_value + h_value < f_value[neighbor]:\n cost_so_far[neighbor] = g_value\n f_value[neighbor] = g_value + h_value\n frontier.put(neighbor, g_value + h_value)\n parents[neighbor] = actual_node\n print(\"found path from: \" + str(start) + \" to: \" + str(final))\n return final_path_list","def problem5(self, s):\n points = 0\n\n points = self.neighbor( 10, 10, s.nearest_neighbor)*3\n points += self.neighbor(100, 10, s.nearest_neighbor)*3\n points += self.neighbor( 10, 100, s.nearest_neighbor)*3\n points += self.neighbor(100, 100, s.nearest_neighbor)*3\n points += self.neighbor(100, 100, s.nearest_neighbor)*3\n\n _testDriver.get_code(s.nearest_neighbor)\n print \"\\n(Check that scipy.spatial.KDTree is not used)\"\n points *= self.grade(1)\n \n return points","def anneal(solution):\n old_cost = cost(solution)\n T = 1.0\n T_min = 0.00001\n ALPHA = 0.9\n\n while T > T_min:\n i = 1\n while i <= 100:\n new_solution = neighbor(solution)\n new_cost = cost(new_solution)\n ap = acceptance_probability(old_cost, new_cost, T)\n if ap > random.random():\n solution = new_solution\n old_cost = new_cost\n i += 1\n T = T * ALPHA\n\n return solution, old_cost","def a_star_search(problem, heuristic=null_heuristic):\r\n \"*** YOUR CODE HERE ***\"\r\n fringe = util.PriorityQueue()\r\n path = set()\r\n final = []\r\n acts = dict()\r\n state = problem.get_start_state()\r\n fringe.push(state, 0)\r\n\r\n while (True):\r\n state = fringe.pop()\r\n path.add(state)\r\n states = problem.get_successors(state)\r\n acts[state] = states[:]\r\n if problem.is_goal_state(state):\r\n break\r\n\r\n states = problem.get_successors(state)\r\n # push into fringe\r\n for stat in states:\r\n if stat[0] not in path:\r\n \"\"\"\r\n it does worse in corners problems, to work better needs heavy huristic, not worth in\r\n in corners problem expandend nodes grow expo\r\n all others are better\r\n counter = 0 # in some situation it helps, in some it doesnt\r\n #print(stat[0].pieces)\r\n for x in stat[0].pieces[0]:\r\n if x:\r\n counter += 1\r\n \"\"\"\r\n counter = 0\r\n fringe.push(stat[0], stat[2] + counter + heuristic(stat[0], problem)) # problem.get_cost_of_actions([stat[1]])\r\n\r\n while (True):\r\n\r\n for key, val in acts.items():\r\n for va in val:\r\n if va[0] == state:\r\n final.append(va[1])\r\n state = key\r\n break\r\n else:\r\n continue\r\n break\r\n if state == problem.get_start_state():\r\n break\r\n\r\n final.reverse()\r\n\r\n return final","def aStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE ***\"\n class Node:\n def __init__(self, state, parent, action, pathCost):\n self.state = state\n self.parent = parent\n self.action = action\n self.pathCost = pathCost\n\n def solution(self):\n path = list()\n tempNode = self\n while tempNode.state != problem.getStartState():\n path.insert(0, tempNode.action)\n tempNode = tempNode.parent\n return path\n\n def __eq__(self, other):\n if isinstance(other, Node):\n return self.state == other.state\n\n\n def childNode(successor, parent, action, stepCost):\n pathCost = parent.pathCost + stepCost\n child = Node(successor, parent, action, pathCost)\n return child\n\n initialNode = Node(problem.getStartState(), None, None, 0)\n frontier = util.PriorityQueue() #bfs uses a queue\n frontier.push(initialNode, initialNode.pathCost + heuristic(initialNode.state, problem)) #we use f(n) = pathCost + h(n) for the best solution\n explored = set()\n\n while not frontier.isEmpty() :\n nextNode = frontier.pop() #extract from the start of the queue\n if problem.isGoalState(nextNode.state):\n return nextNode.solution()\n explored.add(nextNode.state)\n for successor, action, stepCost in problem.getSuccessors(nextNode.state):\n child = childNode(successor, nextNode, action, stepCost)\n if child.state not in explored:\n frontier.update(child, child.pathCost + heuristic(child.state, problem))\n return []\n util.raiseNotDefined()","def find_solution(self):\n print(\"\\nFinding ICTS Solution...\")\n ######### Fill in the ICTS Algorithm here #########\n result = self.stat_tracker.time(\"time\", lambda: self.bfs())\n if result == -1:\n self.stat_tracker.stats['time'] = -1\n return []\n self.stat_tracker.write_stats_to_file(self.stat_tracker.get_results_file_name())\n return result\n ###################################################","def TSP(noOfCities, cityIndicesExcluding1, citiesDistance):\r\n\r\n # Initializing the DP Matrix\r\n # Dictionary because the subset is also to be saved alongwith end vertex as index of dictionary\r\n dpMatrixDict = {}\r\n\r\n # Base case\r\n dpMatrixDict[ ( 1, ), 1 ] = 0\r\n\r\n # Iterating to solve bigger subproblems using dynamic programming\r\n for subsetSizeWithout1 in range(1, noOfCities):\r\n\r\n # Subset is of size subsetSizeWithout1 + 1\r\n print(\"COMPUTING. ON ITERATION NUMBER : \" + str(subsetSizeWithout1) + \" OUT OF \" + str(noOfCities - 1) )\r\n\r\n # Reducing computation by ignoring off the smaller subproblems solutions no longer required\r\n if subsetSizeWithout1 > 3:\r\n smallerEfficientDpMatrixDict = {}\r\n for key in dpMatrixDict:\r\n if len(key[0]) == subsetSizeWithout1:\r\n smallerEfficientDpMatrixDict[key] = dpMatrixDict[key]\r\n dpMatrixDict = smallerEfficientDpMatrixDict\r\n\r\n # Getting the subsets reuired\r\n sizeSpecificSubsets = getSubsets(cityIndicesExcluding1, subsetSizeWithout1)\r\n\r\n # Base cases\r\n for subset in sizeSpecificSubsets:\r\n dpMatrixDict[subset, 1] = 99999999\r\n\r\n\r\n for subset in sizeSpecificSubsets:\r\n\r\n # Computing through each possible end vertex\r\n for j in subset[1:]:\r\n\r\n # List to store the candidates for minimums\r\n possibilities = []\r\n\r\n # Computing through each possible last hop\r\n for k in subset:\r\n\r\n # Storing possibilities alongwith the end vertex\r\n if k != j:\r\n tupleCopy = tupleCopyWithoutElement(subset, j)\r\n possibilities.append( dpMatrixDict[tupleCopy, k] + citiesDistance[k, j] )\r\n\r\n # Getting the minimum path from the possible minimum candidates\r\n try:\r\n minimumPath = min(possibilities)\r\n dpMatrixDict[subset, j] = minimumPath\r\n except:\r\n continue\r\n\r\n\r\n # List for storing all final possible path candidates containing all the vertices\r\n # and a last hop between the start and end vertex to make a cycle\r\n finalHamiltonianPathCandidates = []\r\n\r\n # Final Set(and/or Subset) including all the vertices\r\n almostCompletePath = tuple(range(1, noOfCities + 1))\r\n\r\n # Adding the last hop of the cycle of hamiltonian path between the end and start vertex\r\n for j in cityIndicesExcluding1:\r\n finalHamiltonianPathCandidates.append( dpMatrixDict[almostCompletePath, j] + citiesDistance[j, 1] )\r\n\r\n # Getting the final minimum solution\r\n hamiltonianPathSolution = min(finalHamiltonianPathCandidates)\r\n\r\n # Printing the solution\r\n print(\"The optimal(minimum) length Hamiltonian path distance is : \" + str( hamiltonianPathSolution ) )\r\n\r\n return","def solve(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix, params=[]):\n locations = student_utils.convert_locations_to_indices(list_of_locations, list_of_locations)\n homes = student_utils.convert_locations_to_indices(list_of_homes, list_of_locations)\n start = list_of_locations.index(starting_car_location)\n\n start_time = time.time()\n\n if params[0] == 'naive':\n car_path, drop_off = naive_solver(locations, homes, start, adjacency_matrix)\n print(\"--- %s seconds ---\" % (time.time() - start_time))\n return car_path, drop_off\n elif params[0] == 'greedy':\n car_path, drop_off = greedy_solver(locations, homes, start, adjacency_matrix)\n print(\"--- %s seconds ---\" % (time.time() - start_time))\n return car_path, drop_off\n elif params[0] == 'three_opt':\n car_path, drop_off = three_opt_solver(locations, homes, start, adjacency_matrix)\n print(\"--- %s seconds ---\" % (time.time() - start_time))\n return car_path, drop_off\n elif params[0] == 'ant_colony':\n car_path, drop_off = ant_colony(locations, homes, start, adjacency_matrix)\n print(\"--- %s seconds ---\" % (time.time() - start_time))\n return car_path, drop_off\n elif params[0] == 'greedy_clustering_three_opt':\n car_path, drop_off = greedy_clustering_three_opt(locations, homes, start, adjacency_matrix, int(params[1]))\n print(\"--- %s seconds ---\" % (time.time() - start_time))\n return car_path, drop_off\n elif params[0] == 'mst':\n car_path, drop_off = mst_solver(locations, homes, start, adjacency_matrix)\n print(\"--- %s seconds ---\" % (time.time() - start_time))\n return car_path, drop_off\n elif params[0] == 'two_opt':\n car_path, drop_off = two_opt_solver(locations, homes, start, adjacency_matrix)\n print(\"--- %s seconds ---\" % (time.time() - start_time))\n return car_path, drop_off\n elif params[0] == 'greedy_clustering_two_opt':\n car_path, drop_off = greedy_clustering_two_opt(locations, homes, start, adjacency_matrix, int(params[1]))\n print(\"--- %s seconds ---\" % (time.time() - start_time))\n return car_path, drop_off\n else:\n pass","def optimize(self):\n self.check_is_ready()\n self.check_infeasibility()\n solution_graph, obj_val = self.find_shortest_network_with_ADH((self.old_network_graph is not None))\n self.solution_graph = gnx.GeoMultiGraph(solution_graph, crs=self.optimization_graph.crs)","def solve_maze(self):\n initial_maze_loc = self.maze.location\n curr_coord = initial_maze_loc\n solution_path_directions = []\n #print(\"in solve_maze:\")\n\n # The agent always chooses the next location with the highest Q value.\n # With this strategy, the agent aims to reach the goal using the\n # most optimal path possible.\n while (self.grid[curr_coord[0]][curr_coord[1]] != 'G' and\n self.grid[curr_coord[0]][curr_coord[1]] != 'E'):\n possible_moves = self.maze.moves()\n\n # Find the next best move.\n best_next_move = (0,0)\n best_next_move_q = float('-inf')\n for move in possible_moves:\n if self.qtable[curr_coord[0]+move[0]][curr_coord[1]+move[1]] >= best_next_move_q:\n best_next_move = move\n best_next_move_q = self.qtable[curr_coord[0]+move[0]][curr_coord[1]+move[1]]\n\n direction = self.maze.moves_to_dirs[best_next_move]\n solution_path_directions.append(direction)\n curr_coord = (curr_coord[0]+best_next_move[0], curr_coord[1]+best_next_move[1])\n self.maze.location = curr_coord\n self.maze.location = initial_maze_loc # reset maze location to initial coord.\n\n return solution_path_directions","def solve_maze(self):\r\n # if there is no maze to solve, cut the method\r\n if not self.generated:\r\n return None\r\n\r\n # initialize with empty path at starting cell\r\n self.path = dict()\r\n current = self.start\r\n\r\n # loop until the ending cell is reached\r\n while True:\r\n while True:\r\n # choose valid direction\r\n # must remain in the grid\r\n # also must not cross a wall\r\n dirNum = random.randint(0,3)\r\n adjacent = self.get_next_cell(current,dirNum,1)\r\n if self.is_valid_direction(current,dirNum):\r\n hasWall = (self.grid[adjacent[0]][adjacent[1]] == 0)\r\n if not hasWall:\r\n break\r\n # add cell and direction to path\r\n self.path[current] = dirNum\r\n\r\n # get next cell\r\n current = self.get_next_cell(current,dirNum,2)\r\n if current == self.end: \r\n break # break if ending cell is reached\r\n\r\n # go to start of path\r\n current = self.start\r\n self.solution.append(current)\r\n # loop until end of path is reached\r\n while not (current == self.end):\r\n dirNum = self.path[current] # get direction\r\n # add adjacent and crossed cells to solution\r\n crossed = self.get_next_cell(current,dirNum,1)\r\n current = self.get_next_cell(current,dirNum,2)\r\n self.solution.append(crossed)\r\n self.solution.append(current)\r\n\r\n self.path = dict()","def solve_tsp(dist):\n\n # number of nodes\n N = dist.shape[0]\n\n # tsp path for quick calculation of cost\n ii = np.arange(N)\n jj = np.hstack((np.arange(1, N), 0))\n\n # for each node, a sorted list of closest nodes\n dsort = [np.argsort(d) for d in dist]\n dsort = [d[d != i] for i, d in enumerate(dsort)]\n\n # randomly initialize path through graph\n path = np.random.permutation(N)\n idx = np.argsort(path)\n cost = np.sum(dist[path[ii], path[jj]])\n \n # keep track of objective function over time\n cost_hist = [cost]\n\n # optimization loop\n node = 0\n while node < N:\n\n # we'll try breaking the connection i -> j\n i = path[node]\n j = path[(node+1) % N]\n \n # since we are breaking i -> j we can remove the cost of that connection\n c = cost - dist[i, j]\n\n # search over nodes k that are closer to j than i\n for k in dsort[j]:\n # can safely continue if dist[i,j] < dist[k,j] for the remaining k\n if k == i:\n node += 1\n break\n\n # break connection k -> p\n # add connection j -> p\n # add connection i -> k\n p = path[(idx[k]+1) % N]\n new_cost = c - dist[k,p] + dist[j,p] + dist[i,k]\n\n # if this swap improves the cost, implement it and move to next i\n if new_cost < cost:\n path = reverse_segment(path, idx[j], idx[k])\n idx = np.argsort(path)\n # make sure that we didn't screw up\n assert np.abs(np.sum(dist[path[ii], path[jj]]) - new_cost) < 1e-6\n cost = new_cost\n # restart from the begining of the graph\n cost_hist.append(cost)\n node = 0\n break\n\n return path, cost_hist","def safeJourney(Alist,s,d):\n #Initialize dictionaries\n dinit = 10**6\n Edict = {} #Explored nodes\n Udict = {} #Unexplored nodes\n path = [[] for l in Alist]\n\n Alen = len(Alist) #length of Alist\n dinits = [dinit]*Alen #list of airport indexes\n Udict = dict(zip(list(range(Alen)),dinits)) #zip into dictionary\n Udict[s] = 0\n path[s] = [s]\n \n #Main search\n while len(Udict)>0:\n #Find node with min d in Udict and move to Edict\n dmin = dinit\n for n,w in Udict.items():\n if w<dmin:\n dmin=w\n nmin=n\n Edict[nmin] = Udict.pop(nmin)\n print(\"moved node\", nmin)\n\n #Update provisional distances for unexplored neighbors of nmin\n \n #for n,w in G.adj[nmin].items():\n for item in Alist[nmin]: #nminth element is a list of two element tuples (node, weight)\n n = item[0] #first elt of tuple is node/neighbour\n w = item[1] #2nd elt is density/weigh\n #for n,w in etc_______________________-\n \n if n in Edict:\n pass\n elif n in Udict:\n #dcomp = dmin + w\n dcomp = max(w,dmin) #take largest value to record most dangerous segment\n if dcomp<Udict[n]:\n print(Udict)\n Udict[n]=dcomp\n path[n] = path[nmin] + [n]\n #path[n].extend(path[nmin])\n #path[n] = path[nmin]\n \n #path[n].append(n) #n not nmin\n print(path)\n # else:\n #dcomp = dmin + w\n # dcomp = max(w,dmin)\n # Udict[n] = dcomp\n #path[n].extend(path[nmin])\n #path[n].append(nmin) \n \n if nmin == d: #if current node is destination\n return path[d],Edict[d]\n return [] #no path","def hillClimbingSearch_RR(problem, p, maxSteps, userInteraction, beQuiet):\n\n import random\n currentState = problem.state\n if not beQuiet:\n problem.visualize(currentState)\n steps = 0\n restarts=0\n bestYet = currentState\n\n # for visualization\n problem.hVals.append(problem.getObjValue(currentState))\n\n while steps<maxSteps:\n if problem.isGlobalOptimum(currentState):\n print(f\"\\nTotal random restarts done: {restarts}.\")\n return steps, bestYet\n if random.random()>=p:\n # make a greedy step\n neighbours = problem.getNeighbours(currentState)\n runningBest = currentState\n for n in neighbours:\n nObjVal = problem.getObjValue(n)\n runningBestVal = problem.getObjValue(runningBest)\n if problem.isBetter(nObjVal, runningBestVal):\n runningBest = n\n if runningBest is currentState:\n # no neighbour is better, check against the bestYet\n runningBestVal = problem.getObjValue(runningBest)\n bestYetVal = problem.getObjValue(bestYet)\n if problem.isBetter(runningBestVal, bestYetVal):\n bestYet = runningBest\n else:\n # jump to best neighbour\n currentState = runningBest\n\n # for visualization later on\n problem.hVals.append(problem.getObjValue(currentState))\n \n if not beQuiet:\n print(\"Greedy step taken.\")\n if userInteraction:\n input(\"Press enter to continue \")\n problem.visualize(currentState)\n currentVal = problem.getObjValue(currentState)\n bestYetVal = problem.getObjValue(bestYet)\n if problem.isBetter(currentVal, bestYetVal):\n bestYet = currentState\n steps+=1\n else:\n # do a random restart\n currentState = problem.getRandomState()\n \n # for visualization later on\n problem.hVals.append(problem.getObjValue(currentState))\n if not beQuiet:\n if userInteraction:\n input(\"Press enter to continue \")\n print(\"Random restart done.\")\n problem.visualize(currentState)\n \n currentVal = problem.getObjValue(currentState)\n bestYetVal = problem.getObjValue(bestYet)\n if problem.isBetter(currentVal, bestYetVal):\n bestYet = currentState\n \n restarts+=1\n steps+=1\n # after running out of steps, return the best yet state\n print(f\"\\n[INFO] Total number of random restarts done: {restarts}.\")\n return steps, bestYet","def aStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE ***\"\n from game import Actions\n\n waiting_list = util.PriorityQueue()\n COSTS = {}\n start_state = problem.getStartState()\n COSTS[start_state] = 0\n waiting_list.push(start_state,0)\n parents = {}\n \n while not waiting_list.isEmpty():\n q_state = waiting_list.pop()\n if problem.isGoalState(q_state):\n target_state = q_state\n break\n for child in problem.getSuccessors(q_state):\n n_cost = COSTS[q_state] + child[2]\n \n if child[0] not in COSTS or n_cost < COSTS[q_state]:\n COSTS[child[0]] = n_cost\n prior = n_cost + heuristic(child[0], problem)\n waiting_list.push(child[0], prior)\n parents[child[0]] = q_state\n\n sequence = []\n prev_state = target_state\n while target_state in parents.keys():\n target_state = parents[target_state]\n direction = Actions.vectorToDirection([prev_state[0] - target_state[0], prev_state[1] - target_state[1]])\n prev_state = target_state\n sequence.append(direction)\n \n return sequence[::-1]","def fastest_path_estimation(sol):\n\n class Path:\n def __init__(self, places, graph):\n self.g = 0 # current cost\n self.graph = graph\n self.visited = [places[0]] # list of already visited attractions\n self.not_visited = copy.deepcopy(places[1:]) # list of attractions not yet visited\n\n def __lt__(self, other):\n return self.g < other.g\n\n def add(self, idx):\n # add the cost\n self.g += self.graph[self.visited[-1], idx]\n # add the to the visited place and remove from the unvisited places\n self.visited.append(idx)\n self.not_visited.remove(idx)\n\n def add_to_heap_queue(path):\n # custom function to add to heap queue sorted by the solution's cost\n heappush(h_queue, path)\n\n if len(sol.not_visited) == 0:\n return 0\n elif len(sol.not_visited) == 1:\n return sol.graph[sol.visited[-1], sol.not_visited[0]]\n\n c = sol.visited[-1]\n pm = sol.not_visited[-1]\n # the heap queue of solution sorted by their cost - change all to tuples with g for dijkstra\n h_queue = []\n\n # the places to use for the graph\n sub_search_places = [c]\n sub_search_places.extend(sol.not_visited)\n\n # push the first \"node\" in the queue\n add_to_heap_queue(Path(sub_search_places, sol.graph))\n while True:\n # take the next solution with the shortest cost\n path = heappop(h_queue)\n # if it contains destination, stop and return that solution\n if pm in path.visited:\n return path.g\n # create a new solution for each neighbor of the current vertex and add it to heap queue\n for place in path.not_visited:\n new_path = copy.deepcopy(path)\n new_path.add(place)\n add_to_heap_queue(new_path)","def solve(G):\n\n dominatingSet = nx.algorithms.approximation.dominating_set.min_weighted_dominating_set(G, weight=\"weight\")\n\n # Create the graph T and input the dominating set.\n T = nx.Graph()\n T.add_nodes_from(dominatingSet)\n\n # When the graph is fully dominated by one node, the cost is zero.\n if len(dominatingSet) == 1:\n return T\n\n # The variable defined below, apsp, stands for all pairs shortest paths from calling NetworkX built-in Dijkstra's algorithm.\n apsp = dict(nx.algorithms.shortest_paths.weighted.all_pairs_dijkstra(G, weight = \"weight\"))\n\n # In each iteration of the following for loop, we connect node to node2.\n node2 = None\n for node in dominatingSet:\n\n connected_nodes = nx.dfs_preorder_nodes(T, source=node2)\n\n print(\"Connecting \", node, \"to\", node2)\n print(node2, \"descendants: \", [n for n in connected_nodes])\n\n if node2 is not None and node2 not in list(connected_nodes):\n\n # We want to connect node to node2 in the cheapest way possible.\n # Thus, we search from all nodes connected to node2.\n # By default, we choose the shortest path from node to node2.\n shortest_path = apsp[node2][1][node]\n path_cost = apsp[node2][0][node]\n\n # Now, evaluate if there is a shorter, cheaper path from a different vertex.\n for connected_node in list(nx.dfs_preorder_nodes(T, source=node2)):\n print(\" Cheapest path from \" + str(connected_node) + \": \" + str(apsp[connected_node][0][node]))\n if apsp[connected_node][0][node] < path_cost:\n shortest_path = apsp[connected_node][1][node]\n path_cost = apsp[connected_node][0][node]\n print(\"Updating best path to \" + str(shortest_path) + \", cost \" + str(path_cost))\n\n print(\"Found path via \" + str(shortest_path) + \" of cost \" + str(path_cost))\n\n # Add all necessary vertices.\n for vertex in shortest_path:\n if vertex not in dominatingSet:\n T.add_node(vertex)\n\n # Add all necessary edges.\n for i in range(len(shortest_path) - 1):\n origin = shortest_path[i]\n terminus = shortest_path[i+1]\n T.add_edge(origin, terminus, weight=G.get_edge_data(origin, terminus)['weight'])\n #T[origin][terminus]['weight'] = G.get_edge_data(origin, terminus)['weight']\n\n node2 = node\n print()\n\n current_average = average_pairwise_distance(T)\n last_average = 4000\n print(current_average)\n\n # Until adding more edges doesn't improve the average pairwise cost\n while current_average < last_average:\n last_average = current_average\n # For every node in T\n for node in nx.dfs_preorder_nodes(T, source=list(T.nodes)[0]):\n neighbors = nx.algorithms.traversal.breadth_first_search.bfs_tree(G, node, reverse=False, depth_limit=1)\n # Get one of its neighbors NOT in T\n for node2 in neighbors:\n # and add the edge between that vertex and its neighbor\n # if it decreases the average pairwise cost.\n if node2 not in T and G.get_edge_data(node, node2)\\\n and G[node][node2]['weight'] < current_average:\n T.add_node(node2)\n T.add_edge(node, node2, weight=G.get_edge_data(node, node2)['weight'])\n new_average = average_pairwise_distance(T)\n if new_average > current_average:\n T.remove_node(node2)\n #T.remove_edge(node, node2)\n else:\n current_average = new_average\n print(\"Adding an edge between\", node, \"and\", node2, \"yields average\", new_average)\n\n\n\n print(\"Dominating vertices:\", [node for node in T])\n\n return T","def get_solution(self):\n start_time = time.clock()\n frontier = [Node(self, None, 0, None)]\n explored = []\n visited = 0\n\n while True:\n visited += 1\n # pop the lowest value from the frontier (sorted using bisect, so pop(0) is the lowest)\n node = frontier.pop(0)\n\n # if the current node is at the goal state, we're done! \n if node.board.h() == 0:\n # recursively compile a list of all the moves\n moves = []\n while node.parent:\n moves.append(node.action)\n node = node.parent\n moves.reverse()\n\n print(\"Time:\", time.clock() - start_time)\n return calcal(moves, self.original)\n # print(\"Solution found!\")\n # print(\"Moves:\", len(moves))\n # print(\"Nodes visited:\", visited)\n # print(\"All moves:\", \", \".join(str(move) for move in moves))\n # break\n else:\n # we're not done yet:\n # expand the node, and add the new nodes to the frontier, as long\n # as they're not in the frontier or explored list already\n for new_node in node.expand():\n if new_node not in frontier and new_node not in explored:\n # use bisect to insert the node at the proper place in the frontier\n bisect.insort(frontier, new_node)\n \n explored.append(node)","def get_routing_solution(self):\n G = self.base_digraph\n s1 = self.sources[0]\n s2 = self.sources[1]\n t1 = self.destinations[0]\n t2 = self.destinations[1]\n\n try:\n m = Model('routing')\n m.setParam('OutputFlag', False)\n\n # variables,\n # We have one variable per edge per session\n # e is the dict of dict for the variables\n e = {}\n r = {}\n for i in [1,2]:\n e[i] = {}\n r[i] = m.addVar()\n for u,v in G.edges():\n e[i][u,v] = m.addVar(lb=0)\n\n m.update()\n\n obj = quicksum(r.values())\n m.setObjective(obj, GRB.MAXIMIZE)\n\n # constraints\n # 1. conservations of flow at all intermediate nodes\n # 2. capacity constraints for each edge\n\n for u,v in G.edges():\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\n\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\n\n for n in G.nodes():\n if n not in [s1, s2, t1, t2]:\n for i in [1, 2]:\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\n m.addConstr(inflow == outflow)\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n for u, v in G.edges():\n G[u][v]['Routing'] = {}\n G[u][v]['Routing'][1] = e[1][u,v].x\n G[u][v]['Routing'][2] = e[2][u,v].x\n return (m.objVal, r[1].x, r[2].x)\n else:\n # something went wrong...err...\n print \"Something was wrong, no optimal solution obtained\"\n return None, None, None\n\n except GurobiError:\n Print ('Error Report from Gurobi')","def aStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE IF YOU WANT TO PRACTICE ***\"\n\n priorityFunc = lambda x: x[2] + 1*heuristic(x[0], problem)\n\n # initialize a priority queue\n open = util.PriorityQueue()\n closed = []\n\n # Retrieve the init state\n init = (problem.getStartState(), ['Stop'], 0)\n open.push(init, priorityFunc(init))\n while not open.isEmpty():\n currNode = open.pop()\n currState = currNode[0]\n currPath = currNode[1]\n currPathCost = currNode[2]\n if problem.isGoalState(currState):\n return currPath[1:]\n else:\n closed.append(currState)\n successors = problem.getSuccessors(currState)\n\n if len(successors) > 0:\n for each in successors:\n newPos = each[0]\n newPathCost = currPathCost + each[2]\n\n if newPos not in closed:\n temp = (each[0], currPath + [each[1]], newPathCost)\n open.update(temp, priorityFunc(temp))\n\n return False","def change_way(coins, opponentLocation, player_location):\n global best_weight, best_path\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(5, coins, player_location, dists_matrix)\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 best_weight = float(\"inf\")\n best_path = []\n api.debug(coins_to_search)\n exhaustive(coins_to_search, player_location, [], 0, dist_matrix)\n meta_route = [player_location] + best_path\n api.debug(meta_route)\n route = u.location_list_to_route(meta_route, route_matrix)\n \n return coins_to_search, meta_route, route, dist_matrix[player_location][meta_route[1]]","def local_optimum(self, tour: Tour):\n better = tour\n cnt = 0\n while better is not None:\n # if cnt % 20 == 0:\n print(\"---------------------------------------------\\n The \", cnt, \"time.\")\n print(\"Improved tour:\", list(better.iter_vertices()))\n print(\"Improved cost:\", self.tour_cost(better))\n cnt += 1\n tour = better\n better = self.improve(tour)\n return tour","def a_star(my_map, start_locs, goal_locs, h_values, agent, constraints):\n\n ##############################\n # Task 1.1: Extend the A* search to search in the space-time domain\n # rather than space domain, only.\n # Build constraint table if there are constraints\n\n constraint_table = build_constraint_table(constraints, agent)\n\n open_list = []\n closed_list = dict()\n nodes_opened = 0\n max_opened = 500\n start_loc = start_locs[0]\n goal_loc = goal_locs[0]\n if len(start_locs) > 1: # If there is more than 1 start location then this is a multi-cell agent\n multi = True\n else:\n multi = False\n\n # determine when the last constraint is on the goal node (or any of the goal node cells in the case of multi-cell)\n earliest_goal_timestep = 0\n if len(constraint_table) != 0:\n for time in [item for item in sorted(list(constraint_table.keys()), reverse=True)]:\n flat_list = [item for sublist in constraint_table[time] for item in sublist]\n if(goal_locs[0] in flat_list):\n earliest_goal_timestep = time\n break\n elif(multi): # if multi cell check if any of the agents goal cells are constrained \n if(goal_locs[1] in flat_list): \n earliest_goal_timestep = time\n break\n\n h_value = h_values[start_loc]\n goal_orientation = orientation(goal_locs)\n\n root = {'loc': start_loc,'orientation': orientation(start_locs), 'g_val': 0, 'h_val': h_value, 'time': 0, 'parent': None}\n push_node(open_list, root)\n closed_list[(root['loc'], root['time'], root['orientation'])] = root\n\n while len(open_list ) > 0 and nodes_opened < max_opened:\n curr = pop_node(open_list)\n nodes_opened = nodes_opened + 1\n \n if curr['loc'] == goal_loc and curr['orientation'] == goal_orientation and curr['time'] >= earliest_goal_timestep:\n return get_path(curr)\n ############################\n child_orient = curr['orientation']\n for dir in range(7):\n if dir < 5:\n child_loc = move(curr['loc'], dir)\n elif not multi: \n continue\n\n if dir == 5:\n # clockwise rotation \n child_orient = curr['orientation'] - 1\n if child_orient < 1:\n child_orient = 4\n if dir == 6:\n # counter-clockwise rotation \n child_orient = curr['orientation'] + 1\n if child_orient > 4:\n child_orient = 1\n \n if test_map(my_map, child_loc[0], child_loc[1], child_orient, dir):\n continue\n \n # check if the head location is constrained \n if is_constrained(curr['loc'], child_loc, child_orient, dir, curr['time'] + 1, constraint_table):\n continue\n\n # if this is a multi cell agent check if the tail is constrained \n if multi:\n # check the next tail location \n row_t, col_t, _, _ = find_tail_positions(curr['loc'][0], curr['loc'][1], curr['orientation'], dir)\n next_row_t, next_col_t, next_row_t_inter, next_col_t_inter = find_tail_positions(child_loc[0], child_loc[1], child_orient, dir)\n\n if is_constrained((row_t,col_t), (next_row_t, next_col_t), child_orient, dir, curr['time'] + 1, constraint_table):\n continue\n\n # if the agent is rotating check if the intermediate location is constrained\n if dir == 5 or dir == 6: \n if is_constrained((row_t,col_t), (next_row_t_inter, next_col_t_inter), child_orient, dir, curr['time'] + 1, constraint_table):\n continue\n\n child = {'loc': child_loc,\n 'orientation': child_orient,\n 'g_val': curr['g_val'] + 1,\n 'h_val': h_values[child_loc] + orient_cost(child_orient, goal_orientation),\n 'time': curr['time'] + 1,\n 'parent': curr}\n\n if (child['loc'], child['time'], child['orientation']) in closed_list:\n existing_node = closed_list[(child['loc'], child['time'], child['orientation'])]\n \n if compare_nodes(child, existing_node):\n closed_list[(child['loc'], child['time'], child['orientation'])] = child\n push_node(open_list, child)\n else:\n closed_list[(child['loc'], child['time'], child['orientation'])] = child\n push_node(open_list, child)\n \n return None # Failed to find solutions","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE ***\"\n path_to_point = {}\n cost_to_point = {}\n\n # Get the start node\n start_node = problem.getStartState()\n fringe_node = [start_node]\n path_to_point[start_node] = []\n cost_to_point[start_node] = problem.getCostOfActions(path_to_point[start_node])\n\n goal_found = False\n\n while(not goal_found):\n #for i in range(100): \n nodes_to_expand = set()\n # get max value node in the fringe node\n min_val = float(\"inf\")\n for one_node in fringe_node:\n # Compute the cost to reach a node\n if cost_to_point[one_node] < min_val:\n min_val = cost_to_point[one_node]\n \n for one_node in fringe_node:\n # Compute the cost to reach a node\n if cost_to_point[one_node] == min_val:\n nodes_to_expand.add(one_node)\n fringe_node.remove(one_node)\n\n # Expand the fringe node \n for one_node in nodes_to_expand:\n path_to_parent = path_to_point[one_node]\n for nxt_node in problem.getSuccessors(one_node):\n pos = nxt_node[0]\n mv = nxt_node[1]\n # check if point already present in path to point\n prev_cost = float(\"inf\")\n if pos in cost_to_point:\n prev_cost = cost_to_point[pos]\n new_path = path_to_parent + [mv]\n if prev_cost > problem.getCostOfActions(new_path):\n path_to_point[pos] = new_path\n cost_to_point[pos] = problem.getCostOfActions(new_path)\n fringe_node.append(pos)\n\n # Check if destination is reached in the fringe node\n for one_node in fringe_node:\n if problem.isGoalState(one_node):\n final_node = one_node\n goal_found = True\n break\n \n #print(len(fringe_node))\n print(final_node)\n print(path_to_point[final_node])\n return path_to_point[final_node] \n\n util.raiseNotDefined()","def solve(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix, params=[]):\n\n\n\n\n path = [starting_car_location]\n dict = {}\n index = 0\n for i in range(len(list_of_locations)):\n if list_of_locations[i] == starting_car_location:\n index = i\n\n path = [index]\n\n G, m = adjacency_matrix_to_graph(adjacency_matrix)\n\n home_indexes = []\n\n for home in list_of_homes:\n for i in range(len(list_of_locations)):\n if list_of_locations[i] == home:\n home_indexes.append(i)\n break\n\n new_adjacency = [[\"x\" for i in range(len(list_of_locations))] for j in range(len(list_of_locations))]\n\n # for sake of figuring out where to walk\n for home in home_indexes:\n di_path = nx.dijkstra_path(G, index, home)\n for i in range(len(di_path) - 1):\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n\n\n for home1 in home_indexes:\n for home2 in home_indexes:\n if not home1 == home2:\n di_path = nx.dijkstra_path(G, home1, home2)\n for i in range(len(di_path) - 1):\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n\n\n\n\n G2, m = adjacency_matrix_to_graph(new_adjacency)\n\n all_driving_path = list(nx.dfs_edges(G2))\n\n\n\n\n walking_to = []\n walking_from = {}\n\n for i in range(len(new_adjacency)):\n if i in home_indexes:\n count = 0\n edge_to = 0\n for j in range(len(new_adjacency)):\n if new_adjacency[i][j] != \"x\":\n count += 1\n edge_to = j\n\n #must ensure that this is not a home that we are already dropping someone off at, otherwise it will cut off a line of two homes\n if count == 1 and i != index and i not in walking_from.keys():\n new_adjacency[i][edge_to] = \"x\"\n new_adjacency[edge_to][i] = \"x\"\n walking_to.append(i)\n if edge_to in walking_from:\n walking_from[edge_to] = walking_from[edge_to] + [i]\n else:\n walking_from[edge_to] = [i]\n\n #\n # for i in range(len(all_driving_path) - 1):\n # #if first vertex in edge is the same, we should walk\n # if all_driving_path[i][0] == all_driving_path[i + 1][0]:\n # print(all_driving_path[i][0])\n # print(all_driving_path[i][1])\n # #get rid of only edge connected to this home\n # new_adjacency[all_driving_path[i][0]][all_driving_path[i][1]] = \"x\"\n # new_adjacency[all_driving_path[i][1]][all_driving_path[i][0]] = \"x\"\n # walking_to.append(all_driving_path[i][1])\n # if all_driving_path[i][0] in walking_from:\n # walking_from[all_driving_path[i][0]] = walking_from[all_driving_path[i][0]] + [all_driving_path[i][1]]\n # else:\n # walking_from[all_driving_path[i][0]] = [all_driving_path[i][1]]\n\n\n\n dropoff_locations = list(walking_from.keys())\n for loc in dropoff_locations:\n if loc in home_indexes:\n dropoff_locations.remove(loc)\n\n\n for loc in dropoff_locations:\n di_path = nx.dijkstra_path(G, loc, home)\n for i in range(len(di_path) - 1):\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n\n for loc in dropoff_locations:\n for home in home_indexes:\n di_path = nx.dijkstra_path(G, loc, home)\n for i in range(len(di_path) - 1):\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n\n\n G2, m = adjacency_matrix_to_graph(new_adjacency)\n # G = G2\n # pos=nx.spring_layout(G2)\n # nx.draw_networkx_nodes(G2,pos)\n # nx.draw_networkx_labels(G2, pos)\n # nx.draw_networkx_edges(G2,pos,width=1.0,alpha=0.5)\n #\n # plt.draw()\n # plt.show()\n\n # condensed shortest paths to edges - use G3 for real\n\n new_adjacency2 = [[\"x\" for i in range(len(list_of_locations))] for j in range(len(list_of_locations))]\n\n for home in home_indexes:\n if home not in walking_to:\n di_path = nx.dijkstra_path(G2, index, home)\n start = di_path[0]\n end = di_path[len(di_path) - 1]\n new_adjacency2[start][end] = 0\n new_adjacency2[end][start] = 0\n for i in range(len(di_path) - 1):\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\n\n\n for home1 in home_indexes:\n for home2 in home_indexes:\n if not home1 == home2 and home1 not in walking_to and home2 not in walking_to:\n di_path = nx.dijkstra_path(G2, home1, home2)\n start = di_path[0]\n end = di_path[len(di_path) - 1]\n new_adjacency2[start][end] = 0\n new_adjacency2[end][start] = 0\n for i in range(len(di_path) - 1):\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\n\n for loc in dropoff_locations:\n di_path = nx.dijkstra_path(G2, index, loc)\n start = di_path[0]\n end = di_path[len(di_path) - 1]\n new_adjacency2[start][end] = 0\n new_adjacency2[end][start] = 0\n for i in range(len(di_path) - 1):\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\n\n for loc in dropoff_locations:\n for home in home_indexes:\n di_path = nx.dijkstra_path(G2, loc, home)\n start = di_path[0]\n end = di_path[len(di_path) - 1]\n new_adjacency2[start][end] = 0\n new_adjacency2[end][start] = 0\n for i in range(len(di_path) - 1):\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\n\n\n\n\n final_G, m = adjacency_matrix_to_graph(new_adjacency2)\n drive_path = list(nx.dfs_edges(final_G, source=index))\n drive_path.append(index)\n\n mst = nx.minimum_spanning_tree(final_G)\n\n\n\n new_mst = nx.MultiGraph(mst)\n for edge in mst.edges():\n new_mst.add_edge(edge[0], edge[1])\n\n\n if new_mst.degree[index] != 0:\n to_remove = []\n for node in new_mst:\n if (new_mst.degree[node] == 0):\n to_remove.append(node)\n new_mst.remove_nodes_from(to_remove)\n\n eulerian = list(nx.eulerian_circuit(new_mst, index))\n\n path = []\n for edge in eulerian:\n path.append(edge[0])\n\n path.append(eulerian[len(eulerian) - 1][1])\n\n already_seen = []\n to_remove = []\n for i in range(len(path) - 1):\n if path[i] in already_seen:\n to_remove.append(i)\n else:\n already_seen.append(path[i])\n\n new_path = []\n for i in range(len(path) - 1):\n if i not in to_remove:\n new_path.append(path[i])\n path = new_path\n print(eulerian)\n else:\n path = [index]\n print(path)\n\n\n\n\n\n\n\n # print(path)\n final_path = []\n for node in path:\n if node == index:\n final_path.append(node)\n # print(\"Index: \", node)\n elif node in home_indexes and node not in walking_to:\n final_path.append(node)\n # print(\"Home but not walking: \", node)\n elif node in dropoff_locations:\n final_path.append(node)\n # print(\"Dropoff loc: \", node)\n final_path.append(index)\n #print(walking_from)\n # print(final_path)\n # nx.draw(mst)\n # plt.draw()\n # plt.show()\n for node in final_path:\n if node in walking_from and node in home_indexes:\n dict[node] = [node] + walking_from[node]\n elif node in home_indexes:\n dict[node] = [node]\n elif node in walking_from:\n dict[node] = walking_from[node]\n\n very_final_path = []\n for i in range(len(final_path) - 1):\n condensed_path = nx.dijkstra_path(G2, final_path[i], final_path[i+1])\n for j in range(len(condensed_path) - 1):\n if condensed_path[j] != condensed_path[j + 1]:\n very_final_path.append(condensed_path[j])\n\n if len(very_final_path) >= 1 and [len(very_final_path) - 1] != index:\n very_final_path.append(index)\n\n if len(very_final_path) == 0:\n very_final_path = [index]\n\n print(very_final_path)\n print(dict)\n\n\n path2 = list(nx.dfs_preorder_nodes(mst, index))\n\n final_path2 = []\n for node in path2:\n if node == index:\n final_path2.append(node)\n # print(\"Index: \", node)\n elif node in home_indexes and node not in walking_to:\n final_path2.append(node)\n # print(\"Home but not walking: \", node)\n elif node in dropoff_locations:\n final_path2.append(node)\n # print(\"Dropoff loc: \", node)\n final_path2.append(index)\n\n\n for node in final_path2:\n if node in walking_from and node in home_indexes:\n dict[node] = [node] + walking_from[node]\n elif node in home_indexes:\n dict[node] = [node]\n elif node in walking_from:\n dict[node] = walking_from[node]\n\n very_final_path2 = []\n for i in range(len(final_path2) - 1):\n condensed_path = nx.dijkstra_path(G2, final_path2[i], final_path2[i+1])\n for j in range(len(condensed_path) - 1):\n if condensed_path[j] != condensed_path[j + 1]:\n very_final_path2.append(condensed_path[j])\n\n if len(very_final_path2) >= 1 and [len(very_final_path2) - 1] != index:\n very_final_path2.append(index)\n\n if len(very_final_path2) == 0:\n very_final_path2 = [index]\n\n opt1 = cost_of_solution(G, very_final_path, dict)\n opt2 = cost_of_solution(G, very_final_path2, dict)\n\n ultra_final_path = []\n if (opt1 <= opt2):\n ultra_final_path = very_final_path\n else:\n ultra_final_path = very_final_path2\n\n return ultra_final_path, dict\n\n pass","def cornersHeuristic(state, problem):\n corners = problem.corners # These are the corner coordinates\n walls = problem.walls # These are the walls of the maze, as a Grid (game.py)\n distance = []\n for i in range(len(corners)):\n distance.append(fabs((corners[i][0] - state[0][0]) + (corners[i][1] - state[0][1])))\n \"*** YOUR CODE HERE ***\"\n return min(distance) # Default to trivial solution","def TSP_ILP(G):\n V1 = range(len(G))\n n, V = len(G), set(V1)\n model = Model() # binary variables indicating if arc (i,j) is used\n # on the route or not\n x = [[model.add_var(var_type=BINARY) for j in V] for i in V]\n # continuous variable to prevent subtours: each city will have a\n # different sequential id in the planned route except the 1st one\n y = [model.add_var() for i in V]\n # objective function: minimize the distance\n model.objective = minimize(xsum(G[i][j]*x[i][j] for i in V for j in V))\n\n # constraint : leave each city only once\n for i in V:\n model += xsum(x[i][j] for j in V - {i}) == 1\n # constraint : enter each city only once\n for i in V:\n model += xsum(x[j][i] for j in V - {i}) == 1 # subtour elimination\n for (i, j) in product(V - {0}, V - {0}):\n if i != j:\n model += y[i] - (n+1)*x[i][j] >= y[j]-n # optimizing\n\n model.verbose = 0\n model.optimize() # checking if a solution was found\n\n if model.num_solutions:\n nc = 0 # cycle starts from vertex 0\n cycle = [nc]\n while True:\n nc = [i for i in V if x[nc][i].x >= 0.99][0]\n cycle.append(nc)\n if nc == 0:\n break\n\n return (model.objective_value, cycle)","def solve(self, debug: bool = False) -> np.ndarray:\n coords = self.start\n priority_queue = [(0, 0, coords, [coords])] # Loss must go first!\n heapq.heapify(priority_queue)\n\n while priority_queue:\n _, distance_, coords, path = heapq.heappop(priority_queue)\n\n neighbors = self.neighbors(coords)\n # all_losses = [distance_ + self.heuristic(n) for n in neighbors]\n all_losses = [self.heuristic(n) for n in neighbors]\n\n not_visited = [n for n in neighbors if n in set(neighbors) - set(path)] # Preserve order\n losses = [all_losses[i] for i in range(len(all_losses))\n if neighbors[i] in not_visited]\n\n for loss, neighbor in [(loss, n) for loss, n in sorted(zip(losses, not_visited))]:\n if neighbor == self.finish:\n coords = neighbor\n self.path = np.array(path + [neighbor])\n priority_queue = []\n break\n else:\n # heapq.heappush(priority_queue, (distance_ + 1 + loss, distance_ + 1, neighbor, path + [neighbor]))\n heapq.heappush(priority_queue, (loss, distance_ + 1, neighbor, path + [neighbor]))\n\n if debug:\n print(coords)\n # print(neighbors)\n # print(losses)\n print([(loss, n) for loss, n in sorted(zip(losses, not_visited))])\n\n if coords != self.finish:\n if debug:\n print(coords, self.finish)\n\n raise NoSolutionsError('No solution has been found.')\n else:\n print('Solution has been found!')\n\n return self.path","def find_solution(self, time_limit=5, objective='min_best_case', sic=True, min_time_policy=True):\n self.open_list = OpenListHeap()\n self.open_dict = {} # A dictionary mapping node tuple to the actual node. Used for faster access.\n self.closed_set = set()\n start_time = time.time()\n start_node = ODState(self.startPositions, self.goalPositions, None, None, (0, 0), self.grid_map)\n self.__add_node_to_open(start_node, objective)\n while len(self.open_list.internal_heap) > 0:\n if time.time() - start_time > time_limit:\n print(f\"ODA timed out. Nodes expanded: {len(self.closed_set)}\")\n print(f'Number of nodes in open: {len(self.open_dict)}')\n raise OutOfTimeError('Ran out of time :-(')\n if len(self.open_dict) + len(self.closed_set) > self.max_nodes:\n raise OutOfTimeError('Expanded too many nodes - Exit prior to memory error :-(')\n best_node = self.open_list.pop() # removes from open_list\n self.__remove_node_from_open(best_node)\n\n if self.is_goal_node(best_node):\n return best_node.calc_solution(self.startPositions, sic) + (len(self.closed_set),)\n\n successors = best_node.expand(self.grid_map, sic, min_time_policy)\n\n for neighbor in successors:\n neighbor_tuple = neighbor.create_tuple()\n if neighbor_tuple in self.closed_set: # Has been expanded.\n continue\n if neighbor_tuple not in self.open_dict: # Reached for the first time.\n self.__add_node_to_open(neighbor, objective)\n else: # We might need to update the node.\n old_node = self.open_dict[neighbor_tuple] # Node wac reached before\n if self.is_new_node_better(neighbor, old_node, objective):\n self.__update_node(neighbor, old_node)\n\n return None, math.inf # no solution","def astar_multi(maze):\n heuristic_lookup = {} \n objs = maze.getObjectives()\n corner_list = maze.getObjectives()\n start = maze.getStart()\n path = []\n dim = maze.getDimensions()\n visited = {}\n lookup_table = {}\n p_queue = []\n edgeset = []\n mintree = {}\n start_heuristic = 0 + multi_dot_heuristic_query(maze, start, objs, edgeset, mintree) \n heuristic_lookup[(start, tuple(objs))] = start_heuristic\n start_state = state(start, corner_list)\n lookup_table[state(start, corner_list)] = (start_heuristic, 0, state((-2, -2)))\n p_queue.append((start_heuristic, state(start, corner_list)))\n while p_queue:\n pair = p_queue.pop(0)\n visited[pair[1]] = lookup_table.get(pair[1])[2]\n if not pair[1].getlist():\n current_state = pair[1]\n while current_state != start_state:\n path.append(current_state.getpos())\n current_state = visited.get(current_state)\n path.append(start)\n path.reverse()\n return path\n else: \n list_of_neighbors = maze.getNeighbors(pair[1].getpos()[0], pair[1].getpos()[1])\n for coordinates in list_of_neighbors:\n current_state = state(coordinates)\n if coordinates in pair[1].getlist():\n new_list = copy.copy(pair[1].getlist())\n new_list.remove(coordinates)\n current_state = state(coordinates, new_list)\n else:\n current_state = state(coordinates, pair[1].getlist()) \n if current_state in visited:\n continue\n if current_state in lookup_table:\n if (lookup_table.get(current_state)[0], current_state) in p_queue:\n cost = lookup_table.get(pair[1])[1] + 1\n queried_heuristic = 0\n if (current_state.getpos(), tuple(current_state.getlist())) in heuristic_lookup:\n queried_heuristic = heuristic_lookup.get((current_state.getpos(), tuple(current_state.getlist())))\n else:\n queried_heuristic = multi_dot_heuristic_query(maze, current_state.getpos(), current_state.getlist(), edgeset, mintree)\n heuristic_lookup[(current_state.getpos(), tuple(current_state.getlist()))] = queried_heuristic\n heuristic = queried_heuristic + cost\n old_heuristic = lookup_table.get(current_state)[0]\n if heuristic < lookup_table.get(current_state)[0]:\n lookup_table[current_state] = (heuristic, cost, pair[1])\n p_queue.remove((old_heuristic, current_state))\n bisect.insort(p_queue, (heuristic, current_state))\n else:\n cost = lookup_table.get(pair[1])[1] + 1\n queried_heuristic = 0\n if (current_state.getpos(), tuple(current_state.getlist())) in heuristic_lookup:\n queried_heuristic = heuristic_lookup.get((current_state.getpos(), tuple(current_state.getlist())))\n else:\n queried_heuristic = multi_dot_heuristic_query(maze, current_state.getpos(), current_state.getlist(), edgeset, mintree) \n heuristic_lookup[(current_state.getpos(), tuple(current_state.getlist()))] = queried_heuristic\n heuristic = queried_heuristic + cost\n lookup_table[current_state] = (heuristic, cost, pair[1])\n bisect.insort(p_queue, (heuristic, current_state))\n return []","def waStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE FOR TASK 2 ***\"\n\n priorityFunc = lambda x: x[2] + 2*heuristic(x[0], problem)\n\n # initialize a priority queue\n open = util.PriorityQueue()\n closed = []\n consistencyCheck = []\n\n # Retrieve the init state\n init = (problem.getStartState(), ['Stop'], 0)\n open.push(init, priorityFunc(init))\n while not open.isEmpty():\n currNode = open.pop()\n currState = currNode[0]\n currPath = currNode[1]\n currPathCost = currNode[2]\n\n h0 = heuristic(currState, problem)\n\n if problem.isGoalState(currState):\n print(\"consistent? :\", consistencyCheck.count(True) == len(consistencyCheck))\n return currPath[1:]\n else:\n closed.append(currState)\n successors = problem.getSuccessors(currState)\n\n if len(successors) > 0:\n for each in successors:\n newState = each[0]\n newPathCost = currPathCost + each[2]\n h1 = heuristic(newState, problem)\n consistencyCheck.append(h0-h1 <= 1)\n if newState not in closed:\n temp = (each[0], currPath + [each[1]], newPathCost)\n open.update(temp, priorityFunc(temp))\n\n return False","def find_path_best_first(world_nparray, heuristic_type=\"\"):\n world_ndarray = np.copy(world_nparray)\n start = tuple(np.argwhere(world_ndarray == -2)[0])\n goal = tuple(np.argwhere(world_ndarray == -3)[0])\n\n world_ndarray[world_ndarray == -2] = 0\n world_ndarray[world_ndarray == -3] = 0\n\n world_tuple = tuple(map(tuple, world_ndarray))\n\n pr_queue = [] # Use heapqueue as priority queue\n heappush(pr_queue, (get_h(start, goal, heuristic_type), 0, \"\", start))\n visited = set() # Each element has to be unique in a set\n graph = get_neighbors(world_tuple)\n route_str = \"\"\n\n while pr_queue:\n _, cost, path, current = heappop(pr_queue)\n if current == goal:\n route_str = path\n break\n if current in visited:\n continue\n visited.add(current)\n for direction, neighbour in graph[current].iteritems():\n heappush(pr_queue, (get_h(neighbour, goal, heuristic_type), cost + 1, path + direction, neighbour))\n world_ndarray[neighbour] = cost + 1\n\n # print \"Expanded nodes(Best First +\", heuristic_type, \"): \", len(visited), \"Path length: \", len(route_str)\n # Convert string directions to 2D(x,y) coordinates\n route_coord = [start]\n for p in route_str:\n route_coord.append(graph[route_coord[-1]][p])\n\n world_ndarray[start] = -2 # Mark the start and end coordinates again\n world_ndarray[goal] = -3\n\n return route_coord, world_ndarray, len(visited), len(route_str)","def solve_model(self,max_wait_time = 0,max_per_veh = 99999, save_output=True):\n self.manager = pywrapcp.RoutingIndexManager(len(self.data['time_matrix']),\n self.data['num_vehicles'], self.data['depot'])\n routing = pywrapcp.RoutingModel(self.manager)\n\n transit_callback_index = routing.RegisterTransitCallback(self.time_callback)\n routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)\n time = 'Time'\n routing.AddDimension(\n transit_callback_index,\n max_wait_time, # allow waiting time\n max_per_veh, # maximum time per vehicle\n False, # Don't force start cumul to zero.\n time)\n time_dimension = routing.GetDimensionOrDie(time)\n # Add time window constraints for each location except depot.\n for location_idx, time_window in enumerate(self.data['time_windows']):\n if location_idx == 0:\n continue\n index = self.manager.NodeToIndex(location_idx)\n time_dimension.CumulVar(index).SetRange(time_window[0], time_window[1]-self.VisitTime)\n # Add time window constraints for each vehicle start node.\n for vehicle_id in range(self.data['num_vehicles']):\n index = routing.Start(vehicle_id)\n time_dimension.CumulVar(index).SetRange(self.data['time_windows'][self.data['depot']][0],\n self.data['time_windows'][self.data['depot']][1])\n for i in range(self.data['num_vehicles']):\n routing.AddVariableMinimizedByFinalizer(\n time_dimension.CumulVar(routing.Start(i)))\n routing.AddVariableMinimizedByFinalizer(\n time_dimension.CumulVar(routing.End(i)))\n '''Routing Settings:https://developers.google.com/optimization/routing/routing_options\n '''\n search_parameters = pywrapcp.DefaultRoutingSearchParameters()\n search_parameters.first_solution_strategy = (\n routing_enums_pb2.FirstSolutionStrategy.PATH_MOST_CONSTRAINED_ARC)\n search_parameters.time_limit.seconds = 3600\n #search_parameters.log_search = True\n search_parameters.local_search_metaheuristic = (\n routing_enums_pb2.LocalSearchMetaheuristic.AUTOMATIC)\n sol_status={0:'ROUTING_NOT_SOLVED: Problem not solved yet.',\n 1:'ROUTING_SUCCESS: Problem solved successfully.',\n 2:'ROUTING_FAIL: No solution found to the problem.',\n 3:'ROUTING_FAIL_TIMEOUT: Time limit reached before finding a solution.',\n 4:'ROUTING_INVALID: Model, model parameters, or flags are not valid.'}\n print('Start Solving the problem....')\n _start_ = systime.time()\n assignment = routing.SolveWithParameters(search_parameters)\n print(\"Solver status: \", sol_status[routing.status()])\n soltime = systime.time()-_start_\n print('Solving takes: '+ str(round(soltime,2))+' Secs')\n if assignment:\n self.print_save_solution(routing, assignment,save_res=save_output)\n else:\n print('Solving Failed')","def tryEverything(g, verbose, graphname):\r\n prio = ['rku', 'random', 'BIL', 'rkd', 'cluHPS', 'rkusd', 'rkuad']\r\n placement = ['eft', 'BIM*', 'OLB', 'MET', 'DL', 'GDL']\r\n costFunction = ['mean', 'median', 'maxmax', 'minmax', 'minmin', 'maxmin']\r\n desc = ['DLS/DC', None, 'DCP']\r\n useOfBIM = [False, True]\r\n insertion = [False, True]\r\n BSA = [False, True]\r\n res: Dict[str, List[float]] = {}\r\n cnt = 0\r\n\r\n for ip, p in enumerate(prio):\r\n for ipl, pl in enumerate(placement):\r\n for ic, c in enumerate(costFunction):\r\n if p != 'BIL' or c == 'mean' or pl in ['DL', 'GDL']:\r\n for idd, d in enumerate(desc):\r\n for iu, u in enumerate(useOfBIM):\r\n for ii, i in enumerate(insertion):\r\n for ib, b in enumerate(BSA):\r\n cnt += 1\r\n name = \";\".join(map(str, [ip, ic, ipl, idd, iu, ii, ib]))\r\n\r\n # dispName = \"-\".join(map(str, [p, pl, c, d, u, i, b]))\r\n # print(\"Heuristic n°\", cnt, \"-\", dispName)\r\n # print(\"Heuristic n°\", cnt, \"-\", name)\r\n\r\n startScheduling = timeit.default_timer()\r\n try:\r\n schedule = computeSchedule(g, strategyPrio=p, costFunction=c,\r\n strategyPlacement=pl,\r\n useOfBIM=u, desc=d,\r\n insertion=i, bsa=b, verbose=verbose)\r\n verifPrec(g, schedule, verbose)\r\n endScheduling = timeit.default_timer()\r\n # print(\"Ended in :\", 1000*(endScheduling - startScheduling), \"ms\")\r\n # print(\"Ended in :\", round(1000 * (endScheduling - startScheduling),2), \"ms\")\r\n timeS = round(1000 * (endScheduling - startScheduling), 2)\r\n # print(f\"timeS : {timeS}\")\r\n if verbose:\r\n print(f\"Time : {timeS}ms\")\r\n res[name] = [round(schedule[getExitTask(g)][2], 6), timeS]\r\n except Exception as _:\r\n\r\n print(\"Error for : \" + name + \" on file \" + graphname)\r\n file = open(\"error.log\", 'a')\r\n file.write(f\"Error for {name} on file {graphname}\\n\")\r\n file.close()\r\n raise _\r\n return res\r\n return res","def main():\n test_file = 'lib/pbk411.tsp'\n limit = 1000\n milestones = [10, 25, 100, 500, 1000]\n\n lx, ly = parse_data(test_file)\n algo = Genalgo(lx, ly)\n current = 0\n\n for i in range(0, limit):\n algo.evolve_new_pop(i)\n if i == milestones[current]:\n cities, distance = get_best(algo)\n cities.append(cities[0])\n make_plot_solved(lx, ly, cities)\n save_plot('solved-' + str(milestones[current]) + '.png')\n print(str(milestones[current]) + ': ' + str(distance))\n current += 1\n\n _, best_tuple = algo.get_best_tours(algo.tours)\n best = algo.tours[best_tuple[0]]\n cities = best.cities\n cities.append(best.cities[0])\n print('Best: ' + str(best.get_cost()))\n\n make_plot_original(lx, ly)\n save_plot('original.png')\n make_plot_solved(lx, ly, cities)\n save_plot('solved.png')","def getHeuristicSolutions(distance,countryNo,heurNo):\n if heurNo>countryNo:\n print \"WARNING: There might be no sense that heurNo > countryNo. There would be repetition\"\n heuristicPop = []\n for ii in range(heurNo):\n # Copy distance list\n tempdist = copy.deepcopy(distance)\n # Pick one guy\n basicPerm = range(countryNo)\n heur = []\n luckyGuy = random.sample(basicPerm,1)[0]\n basicPerm.remove(luckyGuy)\n heur.append(luckyGuy)\n # Get closest neighbour\n for i in range(countryNo-1):\n minval = min(tempdist[luckyGuy][:])\n oldGuy = luckyGuy\n luckyGuy = tempdist[luckyGuy].index(minval)\n basicPerm.remove(luckyGuy)\n heur.append(luckyGuy)\n for jj in range(countryNo):\n tempdist[oldGuy][jj] = inf\n tempdist[jj][oldGuy] = inf\n ind = heur.index(0)\n heur = [heur[(it+ind)%countryNo] for it in range(countryNo)]\n heuristicPop.append(heur)\n return heuristicPop","def heuristic(current, goal):\r\n # return 1\r\n i = current[0] - goal[0]\r\n j = current[1] - goal[1]\r\n return math.sqrt(math.pow(i,2) + math.pow(j,2)) # Your code here\r\n # return math.fabs(current[0] - goal[0]) + math.fabs(current[1] - goal[1])\r","def heuristic_function_hard(node, current_player):\n alpha = 25\n beta = 10\n gamma = 40\n delta = -200\n\n x, y = node.get_neutron_coordinates()\n\n # Calculates the distance between the neutron and the player's home rank\n # and calculates how many paths exist for the neutron to reach the player's home rank\n # as well as for the opponent\n if current_player == PLAYER_A:\n neutron_distance = y\n\n player_paths = get_number_of_paths(node, x, y, PLAYER_A)\n opponent_paths = get_number_of_paths(node, x, y, PLAYER_B)\n\n else:\n neutron_distance = node.board_size - y\n\n player_paths = get_number_of_paths(node, x, y, PLAYER_B)\n opponent_paths = get_number_of_paths(node, x, y, PLAYER_A) \n\n surrounding_soldiers = 0\n\n # Calculates the number of surrounding soldiers\n for j in range(-1, 2):\n for i in range(-1, 2):\n\n if x + i < 0 or x + i >= node.board_size or y + j < 0 or y + j >= node.board_size:\n continue\n elif node.board[y+j][x+i] == PLAYER_A_SOLDIER_CHAR or node.board[y+j][x+i] == PLAYER_B_SOLDIER_CHAR:\n surrounding_soldiers += 1\n\n return alpha*neutron_distance + beta*surrounding_soldiers + gamma*player_paths + delta*opponent_paths","def heuristic_main(data):\n arcs, nodes, periods = data.arcs.size, data.nodes, data.periods\n commodities = data.commodities\n arc_origins, arc_destinations = get_2d_index(data.arcs, nodes)\n\n model = make_model(data)\n\n open_arcs = np.zeros((periods, arcs), dtype=np.double)\n\n objective = 0.\n\n for t in xrange(periods):\n fixed_cost, variable_cost = data.fixed_cost[t, :], data.variable_cost\n demand = data.demand[t, :]\n flow, arc_open = model._flow, model._arc_open\n\n for arc in xrange(arcs):\n i, j = arc_origins[arc], arc_destinations[arc]\n con_name = 'cap_{}-{}'.format(i, j)\n con = model.getConstrByName(con_name)\n # We pay for arcs that are not already open\n if arc_open[arc].lb == 0:\n arc_open[arc].obj = fixed_cost[arc]\n for c in xrange(commodities):\n model.chgCoeff(con, flow[c, arc], demand[c])\n flow[c, arc].obj = variable_cost[arc] * demand[c]\n model.optimize()\n if model.status == grb.GRB.status.INFEASIBLE:\n model.computeIIS()\n print 'model is infeasible'\n model.write(str(model.ModelName) + '_{}.ilp'.format(t))\n if model.SolCount > 0:\n objective += model.objVal\n # If we use an arc and it has not been opened before, we should\n # mark it as open now, and keep it open all along\n for count, var in enumerate(arc_open):\n if var.X > 0.1:\n var.lb = 1.\n var.obj = 0.\n if np.sum(open_arcs[:t, count]) < 10e-5:\n open_arcs[t, count] = 1.\n print 'Period : {} Objective value: {}'.format(t, objective)\n\n return objective, open_arcs","def aStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE ***\"\n # Priority Queue to hold the node along with the path taken from the start node to reach that node\n pqueue = PriorityQueue()\n #Set to hold the node explored.\n explorednode = set()\n # Get the start node.\n startnode = problem.getStartState()\n # Push the starting node on the Queue along with an empty set to know the direction in order to reach the node.\n pqueue.push((startnode, []), 0)\n\n # Loop till the priority queue is empty\n while pqueue.isEmpty() is not True:\n # Pop the currentnode and the direction from the priority queue\n (currentnode, direction) = pqueue.pop()\n # Check if the currentnode is not in the explored node.\n if currentnode not in explorednode:\n # We will now add the node to set of explored node.\n explorednode.add(currentnode)\n # If the node is the goal. We made it!!\n if problem.isGoalState(currentnode):\n # The direction holds the way to reach till the goal from the start node.\n return direction\n # Loop for each successor(child) of the current node.\n for (successor, action, stepCost) in problem.getSuccessors(currentnode):\n # Add the successor to the queue along with the path to reach it.\n if successor not in explorednode:\n # Add the successor to the queue along with the path to reach it.\n pqueue.push((successor, direction + [action]), problem.getCostOfActions(direction + [action]) + heuristic(successor, problem))\n util.raiseNotDefined()","def enforced_hillclimbing_search(planning_task, heuristic,\n use_preferred_ops=False):\n # counts the number of loops (only for printing)\n iteration = 0\n # fifo-queue storing the nodes which are next to explore\n queue = deque()\n initial_node = searchspace.make_root_node(planning_task.initial_state)\n queue.append(initial_node)\n best_heuristic_value = heuristic(initial_node)\n logging.info(\"Initial h value: %f\" % best_heuristic_value)\n # set storing the explored nodes, used for duplicate detection\n closed = set()\n visited = set()\n while queue:\n iteration += 1\n # get the next node to explore\n node = queue.popleft()\n # remember the successor state\n closed.add(node.state)\n visited.add(node.state)\n # exploring the node or if it is a goal node extracting the plan\n if planning_task.goal_reached(node.state):\n logging.info(\"Goal reached. Start extraction of solution.\")\n logging.info(\"%d Nodes expanded\" % len(visited))\n return node.extract_solution()\n\n # for the preferred operator version --> recompute heuristic and\n # relaxed plan\n if use_preferred_ops:\n (rh, rplan) = heuristic.calc_h_with_plan(node)\n logging.debug(\"relaxed plan %s \" % rplan)\n\n for operator, successor_state in planning_task.get_successor_states(\n node.state):\n\n # for the preferred operator version ignore all non preferred\n # operators\n if use_preferred_ops:\n if rplan and not operator.name in rplan:\n # ignore this operator if we use the relaxed plan criterion\n logging.debug('removing operator %s << not a preferred '\n 'operator' % operator.name)\n continue\n else:\n logging.debug('keeping operator %s' % operator.name)\n\n # duplicate detection\n if successor_state not in closed:\n successor_node = searchspace.make_child_node(node, operator,\n successor_state)\n heuristic_value = heuristic(successor_node)\n if heuristic_value == float('inf'):\n continue\n elif heuristic_value < best_heuristic_value:\n # Just take the first successor node that has a lower\n # heuristic value than the current best_heuristic_value\n # and ignore the other successor nodes.\n logging.debug(\"Found new best h: %f after %d expansions\" %\n (heuristic_value, iteration))\n queue.clear()\n closed.clear()\n best_heuristic_value = heuristic_value\n queue.append(successor_node)\n break\n else:\n queue.append(successor_node)\n logging.info(\"No operators left. Task unsolvable.\")\n logging.info(\"%d Nodes expanded\" % len(visited))\n return None","def solve(self):\r\n while not self.done():\r\n self.no_open_cells()\r\n self.all_cells_are_mines()\r\n self.no_mines()\r\n if not self.done():\r\n self.obvious_cells()\r\n if not self.done():\r\n made_progress = self.safe_neighbour_difference()\r\n if made_progress:\r\n continue\r\n if not self.done():\r\n made_progress = self.adjacent_combinations()\r\n if made_progress:\r\n continue\r\n return","def solve(self, state, times):","def solve(num_wizards, num_constraints, wizards, constraints):\n print(\"starting time\")\n start = time.time()\n print(\"hello\")\n end = time.time()\n print(\"time taken\",end - start)\n random.shuffle(wizards)\n assignment = wizards\n loop_counter = 0\n temperature = 10.0\n while not numSat(constraints, assignment) == len(constraints):\n loop_counter += 1\n if loop_counter % 500 == 0:\n print(\"numSat\", numSat(constraints, assignment))\n print(\"loops\",loop_counter)\n print(\"time taken\", time.time()-start)\n a = random.sample([i for i in range(len(wizards))], 1)\n b = random.sample([i for i in range(len(wizards))], 1)\n new_assignment = swap(assignment, a[0], b[0])\n delta = numSat(constraints, assignment) - numSat(constraints, new_assignment)\n if delta < 0:\n print(\"delta negative\")\n assignment = new_assignment\n else: \n # print(\"sample greater than expo\")\n sample = random.uniform(0.0,1.0)\n expo = np.exp(-1*float(delta) / temperature)\n if sample < expo:\n # print(\"sample less than expo\")\n assignment = new_assignment\n temperature -= 0.2\n\n print(\"Solved BITCH! numSat:\", numSat(constraints, assignment))\n return assignment","def nearest_neighbor(FILE_NAME):\n time_0 = DEFAULT_TIMER()\n list_of_cities = read_in_file(FILE_NAME)\n best_opt_distance = sys.maxsize\n best_sol_of_cities = []\n\n for city in list_of_cities: #iterate through all cities in the list\n for resetCity in list_of_cities: #reset them all to not visited\n resetCity[3] = False\n sol_of_cities = [] #set our current solution to empty\n opt_distance = 0 #reset our current optimal solution\n nearest_dist = sys.maxsize #nearest distance is huge\n nearest_city = 0\n first_city = city #the first city visited is the next city in our iteration\n first_city[3] = True\n sol_of_cities.append(first_city[0])\n\n city_1 = first_city\n\n while len(sol_of_cities) < len(list_of_cities): #check the current city to\n #find the closest city in the\n #list of cities not visited\n nearest_dist = sys.maxsize\n for city_2 in list_of_cities:\n #if the two cities are not the same and have not visited the second city\n if city_1[0] != city_2[0] and city_2[3] != True:\n dx = city_1[1] - city_2[1]\n dy = city_1[2] - city_2[2]\n dist_to = int(round(math.sqrt((dx*dx) + (dy*dy))))\n #update nearest_city if the new distance is less than the current nearest distance\n if dist_to < nearest_dist:\n nearest_dist = dist_to\n nearest_city = city_2\n#add the city only if we haven't already visited it. Had a wierd bug need to investigate this further\n if nearest_city[3] != True: \n sol_of_cities.append(nearest_city[0])\n opt_distance += nearest_dist\n nearest_city[3] = True\n city_1 = nearest_city\n #quit if our distance is larger than our best solution found\n if(opt_distance > best_opt_distance):\n #print(\"quit this search\") #comment out, see skipped searches\n break\n#add the distance from the last city we visited back to the first city to make a tour\n dx = nearest_city[1] - first_city[1]\n dy = nearest_city[2] - first_city[2]\n opt_distance += int(round(math.sqrt((dx*dx) + (dy*dy))))\n#if our current solution is better than the previous solution replace it, then start over until we've checked all cities\n if best_opt_distance > opt_distance:\n best_opt_distance = opt_distance\n best_sol_of_cities = sol_of_cities\n #print(best_sol_of_cities) #can remove later for testing now\n #print(best_opt_distance) #same as above\n \n write_to_file(best_sol_of_cities, best_opt_distance, FILE_NAME)\n time_1 = DEFAULT_TIMER()\n print(\"Time taken: \", (time_1 - time_0))","def AStar_search(problem, heuristic=nullHeuristic):\n root_node = Node(problem.getStartState(), [], 0, None, 0)\n frontier = util.PriorityQueue()\n frontier.push(root_node, 0 + heuristic(root_node.state, problem))\n explored = []\n nodes_list = list(problem.G.nodes)\n # heuristic_value = [heuristic(x,problem) for x in nodes_list]\n # print problem.start_node\n # print problem.end_node\n while not(frontier.isEmpty()):\n\n \tnode_to_explore = frontier.pop()\n \tif problem.isGoalState(node_to_explore.state):\n \t\t# recontruct_path\n \t\t# print \"Some thing\"\n \t\t# print node_to_explore.parent_node.state\n \t\troute_list = [node_to_explore.state]\n \t\tparent = node_to_explore.parent_node\n \t\twhile parent != None:\n \t\t\troute_list.append(parent.state)\n \t\t\tparent = parent.parent_node\n \t\troute_list.reverse()\n \t\t# print route_list\n \t\treturn route_list\n \telse:\n\t\t\tcopy_state = node_to_explore.state\n\t\t\t# successors_state = problem.getSuccessors(copy_state)\n\t\t\tif copy_state not in explored:\n\t\t\t\texplored.append(copy_state)\n\t\t\t\tsuccessors_state = problem.getSuccessors(copy_state)\n\t\t\t\tif len(successors_state) > 0:\n\t\t\t\t\tfor suc_act_cost in successors_state:\n\t\t\t\t\t\tif suc_act_cost[0] in explored:\n\t\t\t\t\t\t\tcontinue\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tcost = node_to_explore.path_cost + suc_act_cost[2]\n\t\t\t\t\t\t\tcost_with_heuristic = cost + heuristic(suc_act_cost[0], problem)\n\t\t\t\t\t\t\tfrontier.update(Node(suc_act_cost[0], suc_act_cost[1], cost , node_to_explore, node_to_explore.depth + 1), cost_with_heuristic)\n\t\t # util.raiseNotDefined()\n # print len(explored)","def tinyMazeSearch(problem):\r\n from game import Directions\r\n s = Directions.SOUTH\r\n w = Directions.WEST\r\n return [s,s,w,s,w,w,s,w]","def solution(map):\n # length[i][j] = the length of the shortest path from (i,j) to (w-1,h-1).\n # Modify the current location to -1 and continue searching from adjacent spaces.\n return Maze(map).shortest_length()","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s,s,w,s,w,w,s,w]"],"string":"[\n \"def solve(self):\\n # Use a trivial tour (1-2-3-...-N-1) to set the global upper bound.\\n tour = list(range(self._N))\\n upper_bound = sum([self._G[i][(i + 1) % self._N] for i in range(self._N)])\\n trace = []\\n\\n # Start from a configuration with a single vertex.\\n frontier = [BranchAndBoundConfiguration(self._G, self._N, [0], LOWER_BOUND_METHOD)]\\n\\n # Set the start time.\\n start_time = time.time()\\n\\n # Branch and bound until the frontier set is empty or the time has expired.\\n while frontier and (time.time() - start_time) < self._cutoff_time:\\n # Fetch the most promising configuration.\\n config = heappop(frontier)\\n\\n # Expand configuration by appending a vertex to the path.\\n for v in range(self._N):\\n try:\\n expanded_config = config.expand(v)\\n except ValueError:\\n # Expanded configuration is not valid.\\n continue\\n if expanded_config.is_solution():\\n # Update the global upper bound, if needed.\\n this_solution = expanded_config.get_cycle_cost()\\n if this_solution < upper_bound:\\n # Log it.\\n trace.append((time.time() - start_time, this_solution))\\n # Update the best solution.\\n upper_bound = this_solution\\n tour = list(expanded_config.get_path())\\n elif expanded_config.get_lower_bound() < upper_bound:\\n # Add to the frontier set.\\n heappush(frontier, expanded_config)\\n return (upper_bound, [self._index_to_id[v] for v in tour], trace)\",\n \"def get_shortest_route_floyd(network, start,destination, excludings=[]):\\n\\n # On récupère la liste des villes\\n list_city = network[1].keys()\\n \\n # Si la ville de départ ou de fin n'existe pas\\n if start not in list_city or destination not in list_city:\\n return None\\n\\n # On retire les villes à exclure\\n list_city = [x for x in list_city if x not in excludings]\\n\\n\\n # Initialisation de se qu'on a besoin\\n matrix = []\\n distance = []\\n n = len(list_city)\\n\\n \\n # On construit la matrice adjacente où indique la distance si il existe une autoroute entre 2 villes\\n for x in range(n): \\n matrix.append( [] )\\n distance.append( [] )\\n for y in range(n):\\n road_id = get_road_to(network,list_city[x],list_city[y])\\n if road_id != None:\\n matrix[x].append( get_length(network,road_id) )\\n else:\\n matrix[x].append( None )\\n distance[x].append( [road_id] ) # Autoroute -> format: ['LA']\\n\\n\\t \\n # Algorithme de Floyd\\n for k in range(n):\\n for i in range(n):\\n for j in range(n):\\n if ( matrix[i][k] != None and matrix[k][j] != None ) and ( ( matrix[i][j] == None ) or ( matrix[i][j] > matrix[i][k] + matrix[k][j] ) ):\\n matrix[i][j] = matrix[i][k] + matrix[k][j]\\n\\t\\t \\n\\t\\t # Hors Floyd / Ajout personnel\\n if i != k and j != k: # Si i == k ou j == k, cela veut dire qu'on additionne un résultat supplémentaire à la case ij\\n distance[i][j] = [] # Sinon ca signifie qu'on a trouvé un chemin plus court, du coup on supprime l'ancien chemin\\n distance[i][j].extend( distance[i][k] ) # Chemin d'autoroute parcouru en plus -> format: ['LA','AH']\\n distance[i][j].extend( distance[k][j] ) # Chemin d'autoroute parcouru en plus -> format: ['LA','AH']\\n\\n\\t\\t \\n # On récupère simplement la liste des autoroutes parcourus\\n idx_start = list_city.index( start )\\n idx_destination = list_city.index( destination )\\n distance_minimum = distance[ idx_start ][ idx_destination ]\\n\\n \\n # Si on ne trouve aucune solution, on renvoie None\\n if distance_minimum == [None]:\\n distance_minimum = None\\n \\n return distance_minimum\",\n \"def initialisationTurn(mazeWidth, mazeHeight, mazeMap, preparationTime, turnTime, player_location, opponentLocation, coins) :\\n global route, currentcoin, meta_route, best_weight, best_path, coins_to_search, index\\n\\t#dists_matrix, routes_matrix = u.dists_from_each(coins + [playerLocation], mazeMap)\\n coins_to_search = get_n_shortest(5, coins, player_location, dists_matrix)\\n best_weight = float(\\\"inf\\\")\\n best_path = []\\n exhaustive(coins_to_search, player_location, [], 0, dists_matrix)\\n meta_route = [player_location] + best_path\\n route = u.location_list_to_route(meta_route, routes_matrix)\\n index = 1\\n currentcoin = meta_route[1]\",\n \"def second_heuristic(self):\\r\\n directions = [[-1, -1], [-1, 1], [1, 1], [1, -1]]\\r\\n # aceasta matrice indica valoarea pe care o are mutarea unei piese pe o celula aleasa\\r\\n # se va aduna la media ponderilor adunate in lista weights\\r\\n\\r\\n # mijlocul tablei este punctul cel mai vulnerabil\\r\\n # in timp ce lateralele sunt sigure,iar linia bazei transforma piesa in rege\\r\\n\\r\\n points = [[0, 4, 0, 4, 0, 4, 0, 4],\\r\\n [4, 0, 3, 0, 3, 0, 3, 0],\\r\\n [0, 3, 0, 2, 0, 2, 0, 4],\\r\\n [4, 0, 2, 0, 1, 0, 3, 0],\\r\\n [0, 3, 0, 1, 0, 2, 0, 4],\\r\\n [4, 0, 2, 0, 1, 0, 3, 0],\\r\\n [0, 3, 0, 2, 0, 2, 0, 4],\\r\\n [4, 0, 4, 0, 4, 0, 4, 0]]\\r\\n\\r\\n weights = [0 for i in range(4)]\\r\\n whites, blacks = 0, 0\\r\\n for i in range(8):\\r\\n for j in range(8):\\r\\n\\r\\n # numaram discurile de fiecare culoarea\\r\\n blacks += 1 if self.matrix[i][j] in ['N', 'n'] else 0\\r\\n whites += 1 if self.matrix[i][j] in ['A', 'a'] else 0\\r\\n\\r\\n if self.matrix[i][j] in [self.current_player, self.current_player.upper()]:\\r\\n\\r\\n # daca e piesa normala\\r\\n if self.matrix[i][j] == self.current_player:\\r\\n weights[0] += 4\\r\\n\\r\\n # cat de aproape este piesa de a deveni rege ( nr de linii din tabla - cate mai are pana ajunge pe ultima linie)\\r\\n\\r\\n # cu cat se apropie piesa mai multe de a deveni rege, scorul creste( negru - rege pentru i=0, alb -rege pentru i =7)\\r\\n if self.matrix[i][j] == 'n':\\r\\n weights[1] += (7 - i)\\r\\n elif self.matrix[i][j] == 'a':\\r\\n weights[1] += i\\r\\n else:\\r\\n # daca e piesa rege\\r\\n weights[0] += 8\\r\\n\\r\\n # cat de aproape este piesa rege de celelalte piese\\r\\n for d in directions:\\r\\n if self.matrix[i][j] == self.current_player.upper():\\r\\n # gaseste pe diagonala in directia d, o piesa adversara,daca exista\\r\\n x, y = self.find_piesa(i, j, d)\\r\\n if x and y:\\r\\n weights[2] += (x - i) * (x - i) + (y - j) * (y - j)\\r\\n vx = d[0] + i\\r\\n vy = d[1] + j\\r\\n back_x = i - d[0]\\r\\n back_y = j - d[1]\\r\\n next_x, next_y = vx + d[0], vy + d[1]\\r\\n # piesele pe care le poate captura jucatorul, daca e piesa rege are un scor mai mare\\r\\n if self.bounded(vx, vy) and self.matrix[vx][vy] in [self.opponent(), self.opponent().upper()]:\\r\\n if self.bounded(next_x, next_y) and self.matrix[next_x][next_y] == '.':\\r\\n if self.matrix[next_x][next_y] == self.opponent().upper():\\r\\n weights[3] += 7\\r\\n else:\\r\\n weights[3] += 4\\r\\n # piese care pot fi capturate; la fel daca este piesa rege atunci se scade mai mult scorul\\r\\n if self.bounded(vx, vy) and self.matrix[vx][vy] in [self.opponent(), self.opponent().upper()]:\\r\\n if self.bounded(back_x, back_y) and self.matrix[back_x][back_y] == '.':\\r\\n if self.matrix[vx][vy] == self.opponent().upper():\\r\\n weights[3] -= 6\\r\\n else:\\r\\n weights[3] -= 3\\r\\n # adunam piesa la media sumei date pentru a face AI-ul in caz de egalitate a scorului\\r\\n # sa imi aleaga piesa care ma pozitioneaza mai bine\\r\\n if self.move:\\r\\n return sum(weights) / 4 + points[self.move[0]][self.move[1]]\\r\\n return sum(weights) / 4\\r\\n\\r\\n def __str__(self):\\r\\n s = ' '\\r\\n for i in range(8):\\r\\n s += str(i) + ' '\\r\\n s += '\\\\n'\\r\\n for index, line in enumerate(self.matrix):\\r\\n s += str(chr(index + ord('a'))) + ' '\\r\\n for el in line:\\r\\n s += str(el) + ' '\\r\\n s += '\\\\n'\\r\\n\\r\\n return s\",\n \"def rrt_search(self):\\n self.tree.AddVertex(self.start_config)\\n self.tree.AddEdge(self.start_config, self.start_config)\\n\\n while True:\\n x_new, x_nearest = self.new_and_near()\\n if x_new is None:\\n # print(\\\"it's None\\\")\\n continue\\n # connect shortest valid edge\\n # print(\\\"new point\\\", x_new)\\n self.connect_to_point(x_nearest, x_new)\\n\\n # probabilistically check if solution found\\n if self.goal_config in self.tree.vertices:\\n print(\\\"find it\\\")\\n path = self.planning_env.reconstruct_path(self.tree.edges, self.start_config, self.goal_config)\\n if path is not None:\\n return path\\n\\n if self.name=='rrtstar' and self.tree.samples_taken > 10:\\n return []\\n # # check if can connect to goal after generating max_samples\\n if self.tree.samples_taken >= self.tree.max_samples:\\n return []\",\n \"def _optimise(self):\\n better = True\\n self.solutions = set()\\n\\n # Rebuild the neighbours\\n self.neighbours = {}\\n\\n for i in self.heuristic_path:\\n self.neighbours[i] = []\\n\\n for j, dist in enumerate(TSP.edges[i]):\\n if dist > 0 and j in self.heuristic_path:\\n self.neighbours[i].append(j)\\n\\n # Restart the loop each time we find an improving candidate\\n while better:\\n better = self.improve()\\n # Paths always begin at 0 so this should manage to find duplicate\\n # solutions\\n self.solutions.add(str(self.heuristic_path))\\n\\n self.save(self.heuristic_path, self.heuristic_cost)\",\n \"def solve_tsp(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix, params=[]):\\n drop_off_dict = {}\\n car_path = []\\n home_map = {}\\n home_indexes = convert_locations_to_indices(list_of_homes, list_of_locations)\\n\\n start = list_of_locations.index(starting_car_location)\\n graph, msg = adjacency_matrix_to_graph(adjacency_matrix)\\n all_paths = dict(nx.all_pairs_dijkstra(graph))\\n\\n start_in_home = start in home_indexes\\n if start in home_indexes:\\n home_indexes.remove(start)\\n home_indexes.insert(0, start)\\n home_count = 0;\\n\\n for home in home_indexes:\\n #print(home, end = \\\" \\\")\\n home_map[home_count] = home\\n home_count += 1\\n # Instantiate the data problem.\\n #print(len(home_map))\\n data = create_data_model(home_indexes, 0)\\n\\n # Create the routing index manager.\\n manager = pywrapcp.RoutingIndexManager(len(data['locations']),\\n data['num_vehicles'], data['depot'])\\n\\n #print(manager.NodeToIndex(15))\\n # Create Routing Model.\\n routing = pywrapcp.RoutingModel(manager)\\n\\n def distance_callback(from_index, to_index):\\n \\\"\\\"\\\"Returns the distance between the two nodes.\\\"\\\"\\\"\\n # Convert from routing variable Index to distance matrix NodeIndex.\\n #print(home_map[to_index], end = \\\" \\\")\\n from_index = manager.IndexToNode(from_index)\\n to_index = manager.IndexToNode(to_index)\\n dist_to = all_paths.get(home_map[from_index])[0][home_map[to_index]]\\n #if from_index >= 25 or to_index >= 25:\\n # print(\\\"from\\\" if from_index >= 25 else \\\"to\\\", end = \\\" \\\")\\n #dist_to = all_paths[from_index][0][to_index]\\n return dist_to\\n\\n transit_callback_index = routing.RegisterTransitCallback(distance_callback)\\n\\n # Define cost of each arc.\\n routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)\\n\\n # Setting first solution heuristic.\\n \\\"\\\"\\\"\\n search_parameters = pywrapcp.DefaultRoutingSearchParameters()\\n search_parameters.first_solution_strategy = (\\n routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)\\n \\\"\\\"\\\"\\n\\n search_parameters = pywrapcp.DefaultRoutingSearchParameters()\\n search_parameters.local_search_metaheuristic = (\\n routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)\\n search_parameters.time_limit.seconds = 3\\n #search_parameters.log_search = True\\n\\n # Solve the problem.\\n assignment = routing.SolveWithParameters(search_parameters)\\n\\n # if assignment:\\n # print_solution(manager, routing, assignment)\\n # Print solution on console.\\n\\n if start in home_indexes:\\n drop_off_dict[start] = [start]\\n\\n\\n index = routing.Start(0)\\n car_path.append(start)\\n\\n while not routing.IsEnd(index):\\n previous_index = manager.IndexToNode(index)\\n index = assignment.Value(routing.NextVar(index))\\n\\n car_path.pop();\\n to_index = manager.IndexToNode(index)\\n path_to = all_paths.get(home_map[previous_index])[1][home_map[to_index]]\\n drop_off_dict[home_map[to_index]] = [home_map[to_index]]\\n #print(to_index, end = ' ')\\n car_path.extend(path_to)\\n #route_distance += routing.GetArcCostForVehicle(previous_index, index, 0)\\n # for i in car_path:\\n # print(i)\\n if start in drop_off_dict.keys() and not start_in_home:\\n drop_off_dict.pop(start, None)\\n\\n return car_path, drop_off_dict\",\n \"def annealing(nodes, distances, maxTime, ans):\\n\\n #edge cases\\n if len(nodes) == 0:\\n ans[\\\"path\\\"] = []\\n ans[\\\"cost\\\"] = 0\\n return\\n if len(nodes) == 1:\\n ans[\\\"path\\\"] = nodes\\n ans[\\\"cost\\\"] = 0\\n return\\n if len(nodes) == 2:\\n ans[\\\"path\\\"] = nodes\\n ans[\\\"cost\\\"] = totalDist(nodes, distances)\\n return\\n\\n #Picking a starting tour\\n currPath = generateStartingTour(nodes, distances)\\n currCost = totalDist(currPath, distances)\\n\\n startingAnnealingTime = time.time()\\n maxTemperature = maxTime - startingAnnealingTime + 0.05\\n avg = 0\\n while True:\\n #check if time is up\\n t = time.time()\\n if t > maxTime:\\n break\\n \\n #check if current path is best path\\n if currCost < ans[\\\"cost\\\"]:\\n ans[\\\"path\\\"] = currPath\\n ans[\\\"cost\\\"] = currCost\\n #print(ans[\\\"cost\\\"])\\n\\n #try a neighbor\\n skel = randomNeighborSkeleton(currPath, currCost, distances)\\n if skel[0] == 1:\\n i = skel[1]\\n j = skel[2]\\n newCost = skel[3]\\n else:\\n i = skel[1]\\n newCost = skel[2]\\n\\n currTemperature = maxTemperature - (t - startingAnnealingTime)\\n\\n avg = (avg * 1000 + abs(currCost-newCost)) / 1001\\n\\n #move to neighbor with some probability\\n if random.random() < chance(currCost, newCost, currTemperature, maxTemperature, avg):\\n if skel[0] == 1:\\n contiguousFlip(currPath, i, j)\\n else:\\n consecutiveFlip(currPath, i)\\n currCost = newCost\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE ***\\\"\\n def djikstra(Estado_Inicial):\\n from util import PriorityQueue\\n Fila_Estados = PriorityQueue() # cria fila de prioridade\\n Fila_Estados.push((Estado_Inicial, []), 0) # insere tupla do estado inicial e vetor, com prioridade zero\\n Distancia = dict() # cria dicionário para guardar distancia (afim de comparação)\\n Distancia[Estado_Inicial] = 0 # seta distância inicial = 0\\n while(not Fila_Estados.isEmpty()): # enquanto fila não está vazia,\\n Estado_Atual, Caminho = Fila_Estados.pop() # desempilha estado atual e caminho até então\\n if problem.isGoalState(Estado_Atual): # se estado atual é o desejado,\\n return Caminho # retorna caminho\\n for (Sucessor, Acao, Custo) in problem.getSuccessors(Estado_Atual): # verifica sucessores\\n if Sucessor not in Distancia or Distancia[Sucessor] > Distancia[Estado_Atual] + Custo + heuristic(Sucessor, problem):\\n Distancia[Sucessor] = Distancia[Estado_Atual] + Custo + heuristic(Sucessor, problem) # atualiza distância de acordo com sucessor\\n Fila_Estados.push((Sucessor, Caminho + [Acao]), Distancia[Sucessor])\\n return djikstra(problem.getStartState()) # recursividade\",\n \"def get_heuristic(self, state):\\n\\n def get_manhattan_distance(coord_a, coord_b):\\n \\\"\\\"\\\"Returns the manhattan distance between coord_a and coord_b.\\\"\\\"\\\"\\n return abs(coord_a.x - coord_b.x) + abs(coord_a.y - coord_b.y)\\n\\n \\n def get_num_obstacles(coord_a, coord_b):\\n \\\"\\\"\\\"Returns the number of obstacles (wriggler segments or walls) between\\n coord_a and coord_b.\\n \\n This function assumes that coord_b is larger (in either/both x and y)\\n than coord_a.\\n \\\"\\\"\\\"\\n obstacle_count = 0\\n \\n for x in range(coord_a.x, coord_b.x + 1):\\n for y in range(coord_a.y, coord_b.y + 1):\\n coord = Coordinate(x, y)\\n if coord in self.wall_coords or coord in state:\\n obstacle_count += 1\\n \\n return obstacle_count\\n\\n\\n head_coord = state.wriggler_list[0].get_head()\\n tail_coord = state.wriggler_list[0].get_tail()\\n \\n head_manhattan_distance = get_manhattan_distance(head_coord, self.goal_coord)\\n tail_manhattan_distance = get_manhattan_distance(tail_coord, self.goal_coord)\\n \\n # Calculate and return heuristic value depending on which heuristic to use\\n if self.heuristic == Heuristic.MANHATTAN_DIST:\\n # Return the shortest Manhattan distance of wriggler0's tail or head to the goal\\n return min(head_manhattan_distance, tail_manhattan_distance)\\n \\n else: # self.heuristic == Heuristic.NUM_OBSTACLES:\\n # Return the number of obstacles between wriggler0's tail/head to the goal\\n # The tail/head is selected based on which is closer to the goal\\n if head_manhattan_distance <= tail_manhattan_distance:\\n # The head is closer or the same distance away\\n return get_num_obstacles(head_coord, self.goal_coord)\\n \\n else:\\n # The tail is closer\\n return get_num_obstacles(tail_coord, self.goal_coord)\",\n \"def process_solution(self, solution: dict) -> (list, float):\\n start_time = time() * 1000\\n nodes = self.application.nodes()\\n start = np.min(nodes)\\n # fill route with None values\\n route = [None] * len(self.application)\\n # get nodes from sample\\n # NOTE: Prevent duplicate node entries by enforcing only one occurrence per node along route\\n logging.info(str(solution.items()))\\n\\n for (node, timestep), val in solution.items():\\n if val:\\n logging.info((node, timestep))\\n if val and (node not in route):\\n route[timestep] = node\\n\\n # check whether every timestep has only 1 node flagged\\n for i in nodes:\\n relevant_nodes = []\\n relevant_timesteps = []\\n for (node, timestep) in solution.keys():\\n if node == i:\\n relevant_nodes.append(solution[(node, timestep)])\\n if timestep == i:\\n relevant_timesteps.append(solution[(node, timestep)])\\n if sum(relevant_nodes) != 1 or sum(relevant_timesteps) != 1:\\n # timestep or nodes have more than 1 or 0 flags\\n return None, round(time() * 1000 - start_time, 3)\\n\\n # check validity of solution\\n if sum(value == 1 for value in solution.values()) > len(route):\\n logging.warning(\\\"Result is longer than route! This might be problematic!\\\")\\n return None, round(time() * 1000 - start_time, 3)\\n\\n # run heuristic replacing None values\\n if None in route:\\n # get not assigned nodes\\n nodes_unassigned = [node for node in list(nodes) if node not in route]\\n nodes_unassigned = list(np.random.permutation(nodes_unassigned))\\n for idx, node in enumerate(route):\\n if node is None:\\n route[idx] = nodes_unassigned[0]\\n nodes_unassigned.remove(route[idx])\\n\\n # cycle solution to start at provided start location\\n if start is not None and route[0] != start:\\n # rotate to put the start in front\\n idx = route.index(start)\\n route = route[idx:] + route[:idx]\\n\\n # print route\\n parsed_route = ' ->\\\\n'.join([f' Node {visit}' for visit in route])\\n logging.info(f\\\"Route found:\\\\n{parsed_route}\\\")\\n return route, round(time() * 1000 - start_time, 3)\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n n = Directions.NORTH\\n e = Directions.EAST\\n\\n result = []\\n qu = util.PriorityQueue()\\n visited = set([])\\n current = (problem.getStartState(), \\\"\\\", 0)\\n qu.update(current, 0)\\n costs = {}\\n parents = {}\\n parents[problem.getStartState()] = (problem.getStartState(), \\\"\\\")\\n\\n while not qu.isEmpty():\\n cost, current = qu.pop()\\n visited.add(current[0])\\n\\n if problem.isGoalState(current[0]):\\n result = current[0]\\n break\\n\\n for each in problem.getSuccessors(current[0]):\\n if each[0] not in visited:\\n qu.update(each, cost + each[2] + heuristic(each[0], problem))\\n if each[0] not in costs:\\n costs[each[0]] = cost + each[2]\\n parents[each[0]] = (current[0], each[1])\\n elif costs[each[0]] > cost + each[2] + heuristic(each[0], problem):\\n costs[each[0]] = cost + each[2] + heuristic(each[0], problem)\\n parents[each[0]] = (current[0], each[1])\\n\\n path = []\\n while parents[result][0] != result:\\n path.append(parents[result][1])\\n result = parents[result][0]\\n\\n path.reverse()\\n result = []\\n for each in path:\\n if each == \\\"South\\\":\\n result.append(s)\\n elif each == \\\"West\\\":\\n result.append(w)\\n elif each == \\\"North\\\":\\n result.append(n)\\n elif each == \\\"East\\\":\\n result.append(e)\\n\\n return result\\n util.raiseNotDefined()\\n\\n util.raiseNotDefined()\",\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 findHeuristic(self, _, __):\\n popSize = 100\\n retain = 0.25\\n random_select = 0.1\\n mutate = 0.1\\n\\n popList = self.populationList(popSize)\\n\\n solved = False\\n count = 0\\n while not solved:\\n # evolves current\\n popList = (self.evolve(popList, retain, random_select, mutate))\\n# print(popList) # for troubleshooting\\n for i in popList:\\n if (self.fitness(i) == 0):\\n print(\\\"solution: \\\", i)\\n solved = True\\n break\\n # if plateus at a local minima, then end after 50 generations\\n if count >= 50:\\n if (self.fitness(i) <= 10):\\n print(\\\"solution: \\\", i)\\n solved = True\\n break\\n if solved is True:\\n break\\n print(\\\"-----------------\\\")\\n\\n # will modify mutation, random_select and retain values to help leave a\\n # local minima. More randomness the longer it takes up to specific points\\n if count % 3 == 0:\\n if mutate < 0.2:\\n mutate += 0.01\\n if random_select < 0.3:\\n random_select += 0.01\\n count += 1\\n\\n return exit(0)\",\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 calculate_path(self):\\n #Se repite el ciclo para el número especificado de veces\\n for i in range(self.iterations):\\n for ant in self.ants:\\n ant.setup_ant()\\n while not ant.final_node_reached:\\n #Seleccion aleatoria del nodo a visitar\\n node_to_vist = self.select_next_node(self.map.nodes_array[int(ant.actual_node[0])][int(ant.actual_node[1])])\\n #Mover la hormiga al siguiente nodo seleccionado al azar\\n ant.move_ant(node_to_visit)\\n #Compruebe si se ha alcanzado la solución\\n ant.is_final_node_reached()\\n #Agregar la ruta resultante a la lista de rutas\\n self.add_to_path_results(self.delete_loops(ant.get_visited_nodes()))\\n # Habilitar a la hormiga para otra busqueda\\n ant.enable_start_new_path()\\n \\n # Actualizar el nivel global de feromonas\\n self.pheromone_update()\\n self.best_result = self.paths[0]\\n\\n #Vaciar la lista de rutas\\n self.empty_paths()\\n print('Iteration: ', i, 'lenght of the path: ', len(self.best_result))\\n return self.best_result\",\n \"def heuristic(self):\\r\\n # 1.\\r\\n blacks, whites = 0, 0\\r\\n weights = [0 for _ in range(6)]\\r\\n directions = [[-1, -1], [-1, 1], [1, 1], [1, -1]]\\r\\n user_dir = directions[:2] if self.current_player == 'n' else directions[2:]\\r\\n for i in range(8):\\r\\n for j in range(8):\\r\\n blacks += 1 if self.matrix[i][j] in ['N', 'n'] else 0\\r\\n whites += 1 if self.matrix[i][j] in ['A', 'a'] else 0\\r\\n if self.matrix[i][j] == self.current_player or self.matrix[i][j] == self.current_player.upper():\\r\\n\\r\\n # numarul de piese rege\\r\\n if self.matrix[i][j] == self.current_player.upper():\\r\\n weights[1] += 7.75\\r\\n\\r\\n # numarul de piese normale\\r\\n else:\\r\\n weights[0] += 5\\r\\n\\r\\n # numarul de piese de pe baseline in functie de tipul de piesa\\r\\n # conform strategiilor de joc este o strategie buna sa ai cat mai multe\\r\\n # piesa pe baseline pentru a preveni creare de piese de tip rege ale adversarului\\r\\n if self.current_player in ['n', 'N']:\\r\\n if i == 7:\\r\\n weights[2] += 4\\r\\n elif self.current_player in ['a', 'A']:\\r\\n if i == 0:\\r\\n weights[2] += 4\\r\\n\\r\\n # numarul de piese din mijlocul tablei\\r\\n # la fel este o strategie buna pentru atac\\r\\n if 3 <= i <= 4 and 3 <= j <= 4:\\r\\n weights[3] += 2\\r\\n\\r\\n # numar piese vulnerabile\\r\\n # adica piese ce pot fi capturate de oponent la urmatoare tura\\r\\n for d in user_dir:\\r\\n\\r\\n vx = d[0] + i\\r\\n vy = d[1] + j\\r\\n back_x = i - d[0]\\r\\n back_y = j - d[1]\\r\\n next_x, next_y = vx + d[0], vy + d[1]\\r\\n if self.bounded(vx, vy) and self.matrix[vx][vy] in [self.opponent(), self.opponent().upper()]:\\r\\n if self.bounded(back_x, back_y) and self.matrix[back_x][back_y] == '.':\\r\\n weights[4] -= 3\\r\\n if self.bounded(vx, vy) and self.matrix[vx][vy] in [self.opponent(), self.opponent().upper()]:\\r\\n if self.bounded(next_x, next_y) and self.matrix[next_x][next_y] == '.':\\r\\n # daca elimin o piesa rege este o mutare mai buna\\r\\n if self.matrix[vx][vy] == self.opponent().upper():\\r\\n weights[5] += 10\\r\\n else:\\r\\n weights[5] += 7\\r\\n\\r\\n diff = (blacks - whites) if self.current_player == 'n' else (whites - blacks)\\r\\n # cand sunt mai putin piese, AI adopta o tactica mai ofensiva\\r\\n if blacks + whites <= 10:\\r\\n return sum(weights) + diff\\r\\n return sum(weights)\",\n \"def solver(graph,homes,source,home_clusters,all_pairs_distances,all_pairs_shortest_paths):\\n\\n car_path = [get_car_path(graph,home_clusters,source,all_pairs_distances,all_pairs_shortest_paths, \\n source_in_clusters = B1, christofides = B2) for B1 in [False,True] for B2 in [False,True]]\\n\\n dropoffs = [cluster_solver_utils.nearest_dropoff_efficient(graph,path,homes,all_pairs_distances) for path in car_path]\\n cost = [cluster_solver_utils.eval_cost_efficient(graph,car_path[i],dropoffs[i],all_pairs_distances) for i in range(len(car_path))]\\n\\n minimum_cost = min(cost)\\n idx = cost.index(minimum_cost)\\n\\n return minimum_cost, dropoffs[idx], car_path[idx]\",\n \"def optimal_route(graph,homes,source):\\n number_of_homes = len(homes)\\n all_pairs_distances = dict(nx.shortest_path_length(graph, weight = 'weight'))\\n all_pairs_shortest_paths = dict(nx.shortest_path(graph, weight = 'weight'))\\n homes_subgraph = tsp_routines.complete_shortest_path_subgraph_efficient(graph,homes,all_pairs_distances)\\n num_clusters_to_clustering = clustering_routines.all_k_clusters(homes_subgraph,number_of_homes)\\n \\n cluster_list = range(1,number_of_homes+1)\\n optimal_cost = np.Inf\\n optimal_dropoffs = dict()\\n optimal_route = []\\n optimal_num_clusters = 0\\n\\n\\n for num_clusters in cluster_list:\\n home_clusters = num_clusters_to_clustering[num_clusters]\\n cost, dropoffs, route = solver(graph,homes,source,home_clusters,all_pairs_distances,all_pairs_shortest_paths)\\n if cost < optimal_cost:\\n optimal_cost = cost\\n optimal_route = route \\n optimal_dropoffs = dropoffs\\n optimal_num_clusters = num_clusters\\n\\n return optimal_cost, optimal_dropoffs, optimal_route, optimal_num_clusters\",\n \"def cornersHeuristic(state, problem):\\n corners = problem.corners # These are the corner coordinates\\n walls = problem.walls # These are the walls of the maze, as a Grid (game.py)\\n \\\"*** YOUR CODE HERE ***\\\"\\n \\\"\\\"\\\"\\n En este ejercicio me he dado cuenta de un problema de mi definición del espacio de estados:\\n - El espacio de estados consiste en tuplas ((x,y), grid), donde (x,y) es la posición en coordenadas\\n y grid es la tabla de true/false.\\n - El problema es que yo he pensado la tabla grid en forma de matriz matemática, de manera que los índices\\n no van de acuerdo con la posición de las esquinas, sinó con los índices de una matriz.\\n Para solucionar este problema sin tener que modificar todo lo anterior (dado que no me queda tiempo) lo que he\\n tenido que hacer es crear una lista y añadir de forma ordenada los valores true/false, para que se corresponda\\n cada uno con su esquina.\\n \\n Mi heurística consiste en lo siguiente:\\n * Calculo la distancia desde la posición en la que me sitúo hasta todos los corners no visitados (los que aún\\n tienen comida) y me quedo con la mínima de estas distancias, y con el corner que me de esa mínima.\\n * Calculo la distancia desde ese corner (el mínimo de antes) hasta todos los otros posibles corners no visitados\\n y de nuevo me quedo con la mínima distancia y con el corner que me da esa mínima.\\n * Repito este proceso hasta que no queden corners.\\n Entonces lo que hago es definir una nueva lista de corners, newListOfCorners que irá extrayendo los corners a medida\\n que su distanca sea calculada. Por ejemplo, si tengo los cuatro corners con comida y estoy en una posición \\n aleatoria, la lista newListOfCorners estará llena. Se calculará la distancia a cada corner y el corner que de la \\n mínima será extraído de newListOfCorners. Entonces se calculará la distancia desde este corner hasta los restantes\\n tres corners de newListOfCorners y el corner de esos tres que me de la mínima será extraído de la lista. Etc...\\n \\\"\\\"\\\"\\n\\n # Ordenamos la lista de True's y False's para que vaya acorde con el orden de la lista corners:\\n visitedCorners = []\\n visitedCorners.append(state[1][1][0])\\n visitedCorners.append(state[1][0][0])\\n visitedCorners.append(state[1][1][1])\\n visitedCorners.append(state[1][0][1])\\n corners = list(corners) # De aquí saco una lista que contenga los corners ordenados.\\n # Ahora los corners y la lista de visitedCorners contendrán la información de forma ordenada y coherente\\n minimum = 9999999999999999 # Defino un mínimo muy grande para asegurarme que nunca sea superado\\n total = 0 # Inicializo el total a cero\\n newListOfCorners = [] # Creo una nueva lista para añadir los corners no estudiados\\n for corner in corners: # Primero vamos a llenar la lista de corners con los que me interesen: los que tienen comida\\n if visitedCorners[corners.index(corner)]: # Miramos que el corner tenga comida, sino pasamos\\n newListOfCorners.append(corner) # Si tiene comida, lo añadimos\\n minimCorner = corners[0] # Inicializo el minimCorner a un corner aleatorio para que no me de problemas más tarde\\n actualState = state[0] # Lo mismo\\n\\n while not len(newListOfCorners) == 0: # Mientras la lista no esté vacía...\\n for corner in newListOfCorners: # Cogemos un corner de la lista\\n distanceToCorner = manhattanHeuristicToCorners(actualState, corner) # Calculamos dist. a corner\\n if distanceToCorner < minimum: # Calculamos el mínimo\\n minimum = distanceToCorner\\n minimCorner = corner\\n total += minimum # Y lo añadimos al total\\n actualState = minimCorner # Reactualizamos cada variable para volver a empezar el bucle\\n minimum = 9999999999999999999999999999999\\n newListOfCorners.remove(minimCorner)\\n return total\",\n \"def extra(maze):\\n # TODO: Write your code here\\n heuristic_lookup = {} \\n objs = maze.getObjectives()\\n corner_list = maze.getObjectives()\\n start = maze.getStart()\\n path = []\\n dim = maze.getDimensions()\\n visited = {}\\n lookup_table = {}\\n p_queue = []\\n edgeset = []\\n mintree = {}\\n start_heuristic = 0 + multi_dot_heuristic_query(maze, start, objs, edgeset, mintree) * 2\\n heuristic_lookup[(start, tuple(objs))] = start_heuristic\\n start_state = state(start, corner_list)\\n lookup_table[state(start, corner_list)] = (start_heuristic, 0, state((-2, -2)))\\n p_queue.append((start_heuristic, state(start, corner_list)))\\n while p_queue:\\n pair = p_queue.pop(0)\\n visited[pair[1]] = lookup_table.get(pair[1])[2]\\n if not pair[1].getlist():\\n current_state = pair[1]\\n while current_state != start_state:\\n path.append(current_state.getpos())\\n current_state = visited.get(current_state)\\n path.append(start)\\n path.reverse()\\n return path\\n else: \\n list_of_neighbors = maze.getNeighbors(pair[1].getpos()[0], pair[1].getpos()[1])\\n for coordinates in list_of_neighbors:\\n current_state = state(coordinates)\\n if coordinates in pair[1].getlist():\\n new_list = copy.copy(pair[1].getlist())\\n new_list.remove(coordinates)\\n current_state = state(coordinates, new_list)\\n else:\\n current_state = state(coordinates, pair[1].getlist()) \\n if current_state in visited:\\n continue\\n if current_state in lookup_table:\\n if (lookup_table.get(current_state)[0], current_state) in p_queue:\\n cost = lookup_table.get(pair[1])[1] + 1\\n queried_heuristic = 0\\n if (current_state.getpos(), tuple(current_state.getlist())) in heuristic_lookup:\\n queried_heuristic = heuristic_lookup.get((current_state.getpos(), tuple(current_state.getlist())))\\n else:\\n queried_heuristic = multi_dot_heuristic_query(maze, current_state.getpos(), current_state.getlist(), edgeset, mintree) * 2\\n heuristic_lookup[(current_state.getpos(), tuple(current_state.getlist()))] = queried_heuristic\\n heuristic = queried_heuristic + cost\\n old_heuristic = lookup_table.get(current_state)[0]\\n if heuristic < lookup_table.get(current_state)[0]:\\n lookup_table[current_state] = (heuristic, cost, pair[1])\\n p_queue.remove((old_heuristic, current_state))\\n bisect.insort(p_queue, (heuristic, current_state))\\n else:\\n cost = lookup_table.get(pair[1])[1] + 1\\n queried_heuristic = 0\\n if (current_state.getpos(), tuple(current_state.getlist())) in heuristic_lookup:\\n queried_heuristic = heuristic_lookup.get((current_state.getpos(), tuple(current_state.getlist()))) \\n else:\\n queried_heuristic = multi_dot_heuristic_query(maze, current_state.getpos(), current_state.getlist(), edgeset, mintree) * 2\\n heuristic_lookup[(current_state.getpos(), tuple(current_state.getlist()))] = queried_heuristic\\n heuristic = queried_heuristic + cost\\n lookup_table[current_state] = (heuristic, cost, pair[1])\\n bisect.insort(p_queue, (heuristic, current_state))\\n\\n return []\",\n \"def solve(self):\\n smallest_f = self.get_smallest_f_cost_unvisited_node()\\n smallest_f_node = smallest_f[0]\\n\\n if smallest_f[1] > 1:\\n current_node = self.get_smallest_h_cost_unvisited_node()\\n else:\\n current_node = smallest_f_node\\n if current_node.f_cost == self.inf:\\n return\\n\\n self.set_h_cost(current_node)\\n self.unvisited_pos.remove(current_node.pos)\\n self.visited_pos.append(current_node.pos)\\n neighbours = algo_utils.get_neighbours(current_node, self.grid, self.wall_pos)\\n\\n for neigh in neighbours:\\n neighbour_dist = neigh.g_cost\\n current_dist = current_node.g_cost\\n new_dist = current_dist + 1\\n if neighbour_dist < new_dist:\\n continue\\n neigh.g_cost = new_dist\\n self.set_h_cost(neigh)\\n mix_neigh = {neigh.pos: neigh.g_cost}\\n self.mix.update(mix_neigh)\\n mix_current = {current_node.pos: current_node.g_cost}\\n self.mix.update(mix_current)\\n\\n smallest_f = self.get_smallest_f_cost_unvisited_node()\\n smallest_f_node = smallest_f[0]\\n smallest_h_node = self.get_smallest_h_cost_unvisited_node()\\n\\n if (\\n self.end_pos not in self.unvisited_pos\\n or algo_utils.get_smallest_g_cost_unvisited_node(\\n self.grid, self.unvisited_pos\\n ).g_cost\\n == self.inf\\n ):\\n for key, value in self.mix.items():\\n self.mix[key] = round((value * 1.0) / self.end_node.g_cost, 3)\\n self.backtrack_path(self.end_node)\\n else:\\n if smallest_f[1] > 1:\\n current_node = smallest_h_node\\n else:\\n current_node = smallest_f_node\\n self.solve()\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # Initialize data structures\\n parent_node = {}\\n path_to_node = {}\\n priority_queue = util.PriorityQueue()\\n\\n p_c = 0.5\\n h_c = 1 - p_c\\n\\n # Get the start node\\n start_node = problem.getStartState()\\n parent_node[start_node] = None\\n path_to_node[start_node] = []\\n priority_queue.update(start_node, 0)\\n\\n #goal_found = False\\n\\n while not priority_queue.isEmpty():\\n # Get the next node\\n node_to_expand = priority_queue.pop()\\n # Check if goal state is reached\\n if problem.isGoalState(node_to_expand):\\n break\\n next_nodes = problem.getSuccessors(node_to_expand)\\n path_to_parent = path_to_node[node_to_expand]\\n\\n for one_node in next_nodes:\\n point, move, cost = one_node\\n curr_path = path_to_node[node_to_expand] + [move]\\n curr_cost = problem.getCostOfActions(curr_path)\\n heuristic_cost = heuristic(point, problem)\\n # Check if current node already exists in the previously visited nodes\\n if point in path_to_node:\\n prev_cost = problem.getCostOfActions(path_to_node[point])\\n if prev_cost > curr_cost:\\n path_to_node[point] = curr_path\\n priority_queue.update(point, curr_cost + heuristic_cost)\\n \\n else:\\n path_to_node[point] = curr_path\\n priority_queue.update(point, curr_cost + heuristic_cost)\\n \\n # current_cost = problem.getCostOfActions(point) * p_c + heuristic(point, problem) * h_c\\n\\n print(node_to_expand) \\n return path_to_node[node_to_expand]\\n \\n# nodes_to_expand = set()\\n# # get max value node in the fringe node\\n# min_val = float(\\\"inf\\\")\\n# for one_node in fringe_node:\\n# # Compute the cost to reach a node\\n# total_cost = cost_to_point[one_node] * p_c + heuristic(one_node,problem) * h_c\\n# if total_cost < min_val:\\n# min_val = total_cost\\n# \\n# for one_node in fringe_node:\\n# # Compute the cost to reach a node\\n# total_cost = cost_to_point[one_node] * p_c + heuristic(one_node,problem) * h_c\\n# if total_cost == min_val:\\n# nodes_to_expand.add(one_node)\\n# fringe_node.remove(one_node)\\n#\\n# # Expand the fringe node \\n# for one_node in nodes_to_expand:\\n# path_to_parent = path_to_point[one_node]\\n# for nxt_node in problem.getSuccessors(one_node):\\n# pos = nxt_node[0]\\n# mv = nxt_node[1]\\n# # check if point already present in path to point\\n# prev_cost = float(\\\"inf\\\")\\n# if pos in cost_to_point:\\n# prev_cost = cost_to_point[pos]\\n# new_path = path_to_parent + [mv]\\n# if prev_cost > problem.getCostOfActions(new_path):\\n# path_to_point[pos] = new_path\\n# cost_to_point[pos] = problem.getCostOfActions(new_path)\\n# fringe_node.append(pos)\\n#\\n# # Check if destination is reached in the fringe node\\n# for one_node in fringe_node:\\n# if problem.isGoalState(one_node):\\n# final_node = one_node\\n# goal_found = True\\n# break\\n# \\n# #print(len(fringe_node))\\n# print(final_node)\\n# print(path_to_point[final_node])\\n# return path_to_point[final_node] \\n\\n util.raiseNotDefined()\",\n \"def initial_solution(self):\\n cur_node = random.choice(self.nodes) # start from a random node\\n solution = [cur_node]\\n\\n free_nodes = set(self.nodes)\\n free_nodes.remove(cur_node)\\n while free_nodes:\\n next_node = min(free_nodes, key=lambda x: self.dist(cur_node, x)) # nearest neighbour\\n free_nodes.remove(next_node)\\n solution.append(next_node)\\n cur_node = next_node\\n\\n cur_fit = self.fitness(solution)\\n if cur_fit < self.best_fitness: # If best found so far, update best fitness\\n self.best_fitness = cur_fit\\n self.best_solution = solution\\n self.fitness_list.append(cur_fit)\\n return solution, cur_fit\",\n \"def solve(num_wizards, num_constraints, wizards, constraints):\\n\\n # print(num_wizards)\\n # print(num_constraints)\\n # print(wizards)\\n # print(constraints)\\n # node_set = set(wizards)\\n \\n\\n\\n def cost(sol,num_constraints,constraints):\\n constraints_satisfied = 0\\n constraints_failed = []\\n output_ordering_map = {k: v for v, k in enumerate(sol)}\\n for c in constraints:\\n\\n m = output_ordering_map # Creating an alias for easy reference\\n\\n wiz_a = m[c[0]]\\n wiz_b = m[c[1]]\\n wiz_mid = m[c[2]]\\n\\n if (wiz_a < wiz_mid < wiz_b) or (wiz_b < wiz_mid < wiz_a):\\n constraints_failed.append(c)\\n else:\\n constraints_satisfied += 1\\n return num_constraints - constraints_satisfied\\n\\n def neighbors(sol):\\n wiz1 = random.randint(0,num_wizards-1)\\n wiz2 = random.randint(0,num_wizards-1)\\n\\n new_sol = copy.copy(sol)\\n temp = new_sol[wiz1]\\n new_sol[wiz1] = new_sol[wiz2]\\n new_sol[wiz2] = temp\\n \\n return new_sol\\n\\n def acceptance_probability(old_cost,new_cost,T):\\n exponent = (old_cost - new_cost) / T\\n \\n try:\\n ans = math.exp(exponent)\\n except OverflowError:\\n ans = float('inf')\\n return ans\\n\\n\\n def anneal(solution, num_constraints, constraints):\\n old_cost = 0\\n new_cost = 0\\n old_cost = cost(solution,num_constraints,constraints)\\n T = 1.0\\n T_min = 0.000001\\n alpha = 0.98\\n while T > T_min:\\n i = 1\\n while i <= 1000:\\n new_solution = neighbors(solution)\\n new_cost = cost(new_solution,num_constraints,constraints)\\n if new_cost == 0:\\n return new_solution,new_cost\\n ap = acceptance_probability(old_cost, new_cost, T)\\n if ap > random.random():\\n solution = new_solution\\n old_cost = new_cost\\n i += 1\\n T = T*alpha\\n return solution, old_cost\\n\\n s = copy.copy(wizards)\\n random.shuffle(s)\\n ret = anneal(s,num_constraints,constraints)\\n \\n for i in range(10):\\n if ret[1] == 0:\\n break\\n random.shuffle(s)\\n new_ret = anneal(s,num_constraints,constraints)\\n print(i)\\n if new_ret[1] < ret[1]:\\n ret = new_ret\\n print(\\\"constraints failed: {0}\\\".format(ret[1]))\\n return ret[0]\",\n \"def main():\\r\\n start = input(\\\"Enter the starting state: \\\").replace(\\\" \\\", \\\"\\\") # Remove whitespace from states\\r\\n goal = input(\\\"Enter the goal state: \\\").replace(\\\" \\\", \\\"\\\")\\r\\n if validate_input(start, goal) == False:\\r\\n return print(\\\"Invalid input.\\\")\\r\\n\\r\\n start_list = [] # Convert into list for efficieny\\r\\n for i in start:\\r\\n start_list.append(int(i))\\r\\n\\r\\n goal_list = [] # Convert into list for efficieny\\r\\n for i in goal:\\r\\n goal_list.append(int(i))\\r\\n\\r\\n state_inversions = inversions(start_list)\\r\\n print(\\\"\\\\nStart state inversions:\\\", state_inversions)\\r\\n goal_inversions = inversions(goal_list)\\r\\n print(\\\"Goal state inversions:\\\", goal_inversions)\\r\\n\\r\\n if state_inversions % 2 != goal_inversions % 2: # If polarity is uneven, not solvable\\r\\n print(\\\"Unsolvable configurations.\\\\nPolarities do not match.\\\")\\r\\n exit(1)\\r\\n\\r\\n heuristic = -1 # Set heuristic option for A* search\\r\\n while heuristic != 0 and heuristic != 1:\\r\\n try:\\r\\n heuristic = int(input(\\\"\\\\nEnter heuristic function: \\\\n0 for Manhattan\\\\n1 for Eucledian\\\\n= \\\"))\\r\\n except (EOFError, KeyboardInterrupt):\\r\\n print('Terminating.')\\r\\n exit()\\r\\n except (KeyError, ValueError):\\r\\n print('Invalid option.')\\r\\n\\r\\n start_time = time.time() # Start search time\\r\\n nodes_searched = astar_search(start_list, goal_list, heuristic)\\r\\n end_time = time.time() # Stop search timer\\r\\n\\r\\n print(\\\"\\\\nSolved in: {:.2f}\\\".format(end_time-start_time), \\\"seconds\\\")\\r\\n print(\\\"Nodes explored:\\\", nodes_searched)\\r\\n exit()\",\n \"def aStar(sx = 1.55, sy = 2.05, gx = 1.55, gy = 4.05, d_diagnoal = 14, d_straight = 10, grid_reso = 0.1, grid_width = 6, grid_height = 3):\\n width = int(grid_width/grid_reso)\\n height = int(grid_height/grid_reso)\\n #TODO\\n A_sx, A_sy = realPosTogridPos(sx, sy, grid_reso = grid_reso)\\n A_gx, A_gy = realPosTogridPos(gx, gy, grid_reso = grid_reso)\\n startNode = Node(A_sx,A_sy,None,0,0,0)\\n goalNode = Node(A_gx,A_gy,None,0,0,0)\\n # The set of nodes already evaluated\\n closedSet = set()\\n # The set of currently discovered nodes that are not evaluated yet.\\n openSet = set()\\n # Initially, only the start node is known.\\n openSet.add(startNode)\\n # For each node, which node it can most efficiently be reached from.If a node can be reached from many nodes, cameFrom will eventually contain the most efficient previous step.\\n cameFrom = []\\n # For each node, the cost of getting from the start node to that node.\\n gScore = create_gScore(width, height)\\n start_x = startNode.x\\n start_y = startNode.y\\n # The cost of going from start to start is zero.\\n startNode.g_value = 0\\n gScore[start_x][start_y] = 0\\n # For each node, the total cost of getting from the start node to the goal by passing by that node. That value is partly known, partly heuristic.\\n fScore = create_fScore(width, height)\\n # For the first node, that value is completely heuristic.\\n startNode.f_value = heuristic_cost_estimate(startNode, goalNode,d_diagnoal,d_straight)\\n fScore[start_x][start_y] = heuristic_cost_estimate(startNode, goalNode,d_diagnoal,d_straight)\\n while len(openSet) != 0:\\n # current := the node in openSet having the lowest fScore[] value\\n current = node_lowest_fScore(openSet)\\n # If it is the item we want, retrace the path and return it\\n if current.equal(goalNode):\\n path = reconstruct_path(cameFrom, current) # path in real\\n # print \\\"path\\\",path\\n pathInReal = convertGridPathToReal(path, sx, sy, gx, gy, grid_reso = grid_reso) # path in grid\\n return pathInReal\\n\\n openSet.remove(current)\\n closedSet.add(current)\\n current_neighbors = getNeighbors(current, width, height)\\n current_neighbors_num = current_neighbors.shape[1]\\n # for neighbor in current_neighbors:\\n for index in range(current_neighbors_num):\\n [neighbor_x,neighbor_y] = current_neighbors[:,index]\\n neighbor = Node(neighbor_x,neighbor_y,None,np.inf,np.inf,np.inf)\\n if neighbor_in_closedSet(neighbor,closedSet):\\n continue\\n if neighbor_not_in_openSet(neighbor,openSet):\\t# Discover a new node\\n openSet.add(neighbor)\\n\\n # The distance from start to a neighbor the \\\"dist_between\\\" function may vary as per the solution requirements.\\n current_x = current.x\\n current_y = current.y\\n tentative_gScore = gScore[current_x][current_y] + dist_between(current, neighbor,d_diagnoal,d_straight)\\n neighbor_x = neighbor.x\\n neighbor_y = neighbor.y\\n if tentative_gScore >= gScore[neighbor_x][neighbor_y]:\\n continue\\t\\t# This is not a better path.\\n\\n neighbor.father = current\\n cameFrom.append(neighbor)\\n gScore[neighbor_x][neighbor_y] = tentative_gScore\\n neighbor.g_value = tentative_gScore\\n neighbor_f_value = gScore[neighbor_x][neighbor_y] + heuristic_cost_estimate(neighbor, goalNode,d_diagnoal,d_straight)\\n fScore[neighbor_x][neighbor_y] = neighbor_f_value\\n neighbor.f_value = neighbor_f_value\\n return False\",\n \"def solve(num_wizards, num_constraints, wizards, constraints): \\n global wiz_const\\n wiz_const = mapConstraints(wizards, constraints)\\n partial_soltns = []\\n\\n # counter for priority queue since it doesn't allow \\n # identical priorities\\n k = 0\\n\\n # list of wizards sorted by lowest to highest degree\\n sorted_wiz = sortWizByConsts(wiz_const)\\n wiz_rankings = {wiz: i for i, wiz in enumerate(sorted_wiz)}\\n\\n const_set = set(map(tuple, constraints))\\n for i in range(4) : \\n heapq.heappush(partial_soltns, (0, k, nx.DiGraph(), const_set.copy()))\\n k += 1\\n\\n print(\\\"setup done, commencing solving\\\")\\n\\n while len(partial_soltns) : \\n\\n # for partial_soltn, const_set in partial_soltns : \\n# partial_soltns.remove(partial_soltn)\\n num_seen, _, partial_soltn, const_set = heapq.heappop(partial_soltns)\\n const = findNextConst(partial_soltn, const_set, wiz_rankings)\\n print(\\\"seen \\\" + str(len(partial_soltn)) + \\\"\\\\t num partial_solutions\\\\t\\\" + str(len(partial_soltns)))\\n try : \\n const_set.remove(const)\\n except KeyError : \\n print(\\\"BAD SHIT\\\")\\n pass\\n possible_arrangements = [(const[0], const[1], const[2]),\\n (const[2], const[0], const[1]), \\n (const[2], const[1], const[0]),\\n (const[1], const[0], const[2])]\\n for arr in possible_arrangements:\\n soltn = partial_soltn.copy()\\n a, b, c = arr\\n if not (soltn.has_node(a) and soltn.has_node(b) and nx.has_path(soltn, a, b)) : \\n soltn.add_edge(a, b)\\n if not (soltn.has_node(b) and soltn.has_node(c) and nx.has_path(soltn, b, c)) : \\n soltn.add_edge(b, c)\\n # see if we violated any other constraints (seen or not seen)\\n is_valid, num_wiz = validNumWiz(soltn, const_set)\\n\\n if is_valid and len(list(nx.simple_cycles(soltn))) == 0 :\\n heapq.heappush(partial_soltns, (-len(soltn), k, soltn, const_set.copy()))\\n k += 1\\n # are we done?\\n if num_wiz == num_wizards :\\n print(\\\"FINAL SOLUTION (found without processing all constraints but validating against them)\\\")\\n ordering = list(nx.topological_sort(soltn))\\n finishEverything(ordering, constraints)\\n return ordering\\n if foundCompleteOrdering(heapq.heappop(partial_soltns)) : \\n print(\\\"FINAL SOLUTION\\\")\\n ordering = list(nx.topological_sort(soltn))\\n finishEverything(ordering, constraints)\\n return ordering\\n print(\\\"NO SOLUTION FOUND\\\")\\n return \\\"\\\"\",\n \"def solve_tour(self):\\n\\t\\tboard = [[-1 for _ in range(self.N)]for _ in range(self.N)]\\n\\t\\tboard[0][0] = 0\\n\\n\\t\\tz = self.find_tour(board, 0, 0, 1)\\n\\t\\tif z:\\n\\t\\t\\tfor i in range(self.N):\\n\\t\\t\\t\\tfor j in range(self.N):\\n\\t\\t\\t\\t\\tself.solution.append(board[i][j])\\n\\t\\t\\tprint board\\n\\t\\t\\treturn self.solution\\n\\t\\t\\t\\t\\n\\t\\telse:\\n\\t\\t\\tprint(\\\"No solution\\\")\",\n \"def aStarSearch(problem, heuristic=myHeuristic):\\n\\n #frontier = util.PriorityQueue()\\n #startState = problem.getStartState()\\n #startNode = (startState, ['East'], 0)\\n #frontier.push(startNode, 0)\\n\\n #currentState, actions, currentCost = frontier.pop()\\n #return ['West','West', 'West','West','South','South','East', 'South','South','West','West']\\n\\n fronteira = util.PriorityQueue()\\n\\n nohExplorado = [] #(state, cost)\\n\\n startState = problem.getStartState()\\n nohInicial = (startState, [], 0) #(state, action, cost)\\n\\n fronteira.push(nohInicial, 0)\\n\\n while not fronteira.isEmpty():\\n\\n #pega o Noh de menor \\\"custo\\\" na fila\\n curEstado, todasAcoes, curCusto = fronteira.pop()\\n\\n #Coloca Noh atual na lista de explorados\\n nohAtual = (curEstado, curCusto)\\n nohExplorado.append((curEstado, curCusto))\\n\\n if problem.isGoalState(curEstado):\\n #print(todasAcoes)\\n return todasAcoes\\n\\n else:\\n #Lista de Sucessores (successor, action, stepCost) e examina cada um\\n sucessores = problem.getSuccessors(curEstado)\\n for sucEstado, sucAcao, sucCusto in sucessores:\\n novaAcao = todasAcoes + [sucAcao]\\n novoCusto = problem.getCostOfActions(novaAcao)\\n novoNoh = (sucEstado, novaAcao, novoCusto)\\n\\n #Checa se o sucessor jah foi visitado\\n jah_foi_explorado = False\\n for explorado in nohExplorado:\\n exEstado, exCusto = explorado\\n if (sucEstado == exEstado) and (novoCusto >= exCusto):\\n jah_foi_explorado = True\\n\\n #Se nao foi explorado, coloca na fronteira\\n if not jah_foi_explorado:\\n fronteira.push(novoNoh, novoCusto + heuristic(sucEstado, problem))\\n\\n\\n return todasAcoes\",\n \"def solve(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix, params=[]):\\n\\n loc_map = {}\\n drop_off_dict = {}\\n num_home_visited = 0\\n\\n \\\"\\\"\\\"\\n for i in range(len(list_of_locations)):\\n loc_map[i] = list_of_locations[0]\\n \\\"\\\"\\\"\\n\\n home_indexes = convert_locations_to_indices(list_of_homes, list_of_locations)\\n start = list_of_locations.index(starting_car_location)\\n graph, msg = adjacency_matrix_to_graph(adjacency_matrix)\\n num_homes = len(list_of_homes)\\n\\n car_path = []\\n all_paths = dict(nx.all_pairs_dijkstra(graph))\\n visited = set()\\n\\n #print(start)\\n car_path.append(start)\\n current_node = start\\n\\n if start in home_indexes:\\n visited.add(start)\\n drop_off_dict[start] = [start]\\n num_home_visited += 1\\n\\n while num_home_visited < num_homes:\\n dist_dict = all_paths.get(current_node)[0]\\n paths_dict = all_paths.get(current_node)[1]\\n\\n dist_dict = {k:v for (k,v) in dist_dict.items() if k not in visited and k in home_indexes}\\n min_dist = min(dist_dict.values())\\n min_list = [k for k in dist_dict.keys() if dist_dict[k] <= min_dist]\\n #print(dist_dict.values())\\n target = min_list[0]\\n drop_off_dict[target] = [target]\\n #print(target+1)\\n #print(target)\\n car_path.pop()\\n car_path.extend(paths_dict[target])\\n\\n visited.add(target)\\n current_node = target\\n num_home_visited += 1\\n\\n paths_dict = all_paths.get(current_node)[1]\\n car_path.pop()\\n car_path.extend(paths_dict[start])\\n #print((drop_off_dict.keys()))\\n #car_path = [start, ...., start]\\n #drop_off_dict = {drop_off_loc: [home1, home2, ...] }\\n\\n return car_path, drop_off_dict\",\n \"def generate_initial_solution(self, nr_iterations=2000, use_seed=False, seed=1):\\n\\n best_route = None\\n best_score = float('inf')\\n\\n for i in range(nr_iterations):\\n route = Route(self.jobs, self.stores, self.deliverers, self.distances_matrix, self.evaluator)\\n if use_seed:\\n route.generate_initial_route(seed=seed, initialization_method=self.route_initialization_method )\\n else:\\n route.generate_initial_route(seed=i, initialization_method=self.route_initialization_method )\\n\\n route_score = route.evaluate()\\n if route_score < best_score:\\n best_score = route_score\\n best_route = route\\n # assert best_route == None\\n self.solution = best_route\\n return best_score, best_route\",\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 astar(grid, heuristic):\\r\\n\\r\\n print (grid.getStart())\\r\\n frontier = PriorityQueue()\\r\\n frontierCpy = {}\\r\\n\\r\\n goal = grid.getGoals()[0]\\r\\n\\r\\n startX = grid.getStart()[0]\\r\\n startY = grid.getStart()[1]\\r\\n startNode = Node(((startX, startY), 0), None)\\r\\n\\r\\n init_heu = heuristic(startNode.cell[0], goal)\\r\\n frontierCpy[startNode.cell[0]] = init_heu\\r\\n frontier.put((init_heu, 0, startNode))\\r\\n\\r\\n while frontier.qsize() != 0:\\r\\n tup = frontier.get()\\r\\n\\r\\n currNode = tup[2]\\r\\n currG = tup[1] * -1\\r\\n grid.addVisited(currNode.cell[0])\\r\\n frontierCpy.pop(currNode.cell[0], None)\\r\\n\\r\\n if currNode.cell[0] == goal:\\r\\n path = []\\r\\n while currNode != None:\\r\\n path.insert(0, currNode.cell[0])\\r\\n currNode = currNode.parent\\r\\n grid.setPath(path)\\r\\n return path\\r\\n\\r\\n\\r\\n neighbors = grid.getNeighbors(currNode.cell[0])\\r\\n\\r\\n for n in neighbors:\\r\\n if n[0] not in grid.getVisited():\\r\\n newNode = Node(n, currNode)\\r\\n\\r\\n h = heuristic(n[0], goal)\\r\\n\\r\\n oneStepCost = n[1]\\r\\n g = oneStepCost + currG\\r\\n if n[0] not in frontierCpy or frontierCpy[n[0]] > h + g:\\r\\n frontier.put((h+g, -1*g, newNode))\\r\\n frontierCpy[n[0]] = h+g\\r\\n print(\\\"CANT FIND A PATH\\\")\",\n \"def improve(self):\\n tour = Tour(self.heuristic_path)\\n\\n # Find all valid 2-opt moves and try them\\n for t1 in self.heuristic_path:\\n around = tour.around(t1)\\n\\n for t2 in around:\\n broken = set([makePair(t1, t2)])\\n # Initial savings\\n gain = TSP.dist(t1, t2)\\n\\n close = self.closest(t2, tour, gain, broken, set())\\n\\n # Number of neighbours to try\\n tries = 5\\n\\n for t3, (_, Gi) in close:\\n # Make sure that the new node is none of t_1's neighbours\\n # so it does not belong to the tour.\\n if t3 in around:\\n continue\\n\\n joined = set([makePair(t2, t3)])\\n\\n # The positive Gi is taken care of by `closest()`\\n Log.debug(\\\"Start: X: {} - Y: {} = {}\\\".format((t1, t2),\\n (t2, t3), Gi))\\n\\n if self.chooseX(tour, t1, t3, Gi, broken, joined):\\n # Return to Step 2, that is the initial loop\\n return True\\n # Else try the other options\\n\\n tries -= 1\\n # Explored enough nodes, change t_2\\n if tries == 0:\\n break\\n\\n return False\",\n \"def a_star_planning(start_x, start_y, goal_x, goal_y, id):\\n # extract the index of start node, goal node and obstacles\\n start = Point(round(start_x/grid_size), round(start_y/grid_size), 0.0, -1, [0,0,0])\\n goal = Point(round(goal_x/grid_size), round(goal_y/grid_size), 0.0, -1, [0,0,0])\\n if not_legal(goal, id):\\n print ('not a legal goal')\\n return False\\n \\n # time.sleep(10)\\n\\n # create the open list and close list to store nodes\\n openset, closeset = deque(), deque()\\n openset.append(start)\\n\\n while True:\\n # find out the min f node to explore\\n\\n current_node = min(openset,\\n key=lambda node: node.g + calculate_heuristic(node,goal))\\n\\n # pltplt.plot(current_node.x, current_node.y, \\\"b*\\\")\\n if len(closeset) % 10 == 0:\\n plt.pause(0.001)\\n\\n if current_node.x == goal.x and current_node.y == goal.y:\\n print(\\\"Congratulations! You have found the goal!\\\")\\n goal.parent = current_node\\n break\\n\\n # Remove it from the open list\\n openset.remove(current_node)\\n # Add it to the close list\\n closeset.append(current_node)\\n\\n # Explore the neighbour\\n for motion in motions:\\n if motion == current_node.parent_motion:\\n turn_cost = 0\\n elif (motion[0] == -1 * current_node.parent_motion[0]) and (motion[1] == -1 * current_node.parent_motion[1]):\\n turn_cost = 1.5\\n else:\\n turn_cost = 1\\n\\n node = Point(current_node.x + motion[0],\\n current_node.y + motion[1],\\n current_node.g + motion[2] + turn_cost,\\n current_node,\\n motion,\\n )\\n\\n # ignore it if it is in the close list\\n flag = False\\n for item in closeset:\\n if item.x == node.x and item.y == node.y:\\n flag = True\\n break\\n if flag:\\n continue\\n # ignore it if it is obstacle\\n\\n if not_legal(node, id):\\n continue\\n # update its parent if it is the open list\\n flag = True\\n for item in openset:\\n if item.x == node.x and item.y == node.y:\\n flag = False\\n # if closer, update the parent\\n if node.g <= item.g:\\n item.g = node.g\\n item.parent = node.parent\\n item.parent_motion = node.parent_motion\\n break\\n # add to the open list if it is not in the open list\\n if flag:\\n openset.append(node)\\n\\n # generate the final path\\n while True:\\n route = deque()\\n route.append(goal)\\n plt.plot(goal.x, goal.y, \\\"rx\\\")\\n if goal.parent == -1:\\n break\\n else:\\n goal = goal.parent\\n route.appendleft(goal)\\n # return route\\n # return False\\n if NEED_DRAW:\\n # draw map\\n for i in range(map.gridwidth):\\n for j in range(map.gridheight):\\n if map.grid[1,i,j] >0:\\n plt.plot(i, j, \\\"xc\\\")\\n\\n plt.plot(start.x, start.y, \\\"ro\\\")\\n plt.plot(goal.x, goal.y, \\\"go\\\")\\n\\n for goal in route:\\n plt.plot(goal.x, goal.y, \\\"rx\\\")\\n plt.show()\",\n \"def foodHeuristic(state, problem):\\n position, foodGrid = state\\n \\\"*** YOUR CODE HERE ***\\\"\\n \\\"\\\"\\\"\\n Mi heurística consiste en hacer simplemente el máximo de las distancias reales del state a cada nodo con comida\\n He provado diferentes heurísticas y esta es la que me expande menos nodos, aunque no es la más óptima temporalmente\\n Tardé mucho tiempo en darme cuenta de que había una función que calculaba la distancia real entre dos nodos\\n NOTA: NO EJECUTAR CON LABERINTOS MÁS GRANDES QUE EL tinySearch. El algoritmo requiere muchísimo tiempo\\n \\\"\\\"\\\"\\n max = 0 # Inicializo el máximo en 0\\n for food in foodGrid.asList(): # Esto me da cada food como un nodo (x,y), pero sólo los nodos que tengan comida\\n distance = mazeDistance(position, food, problem.startingGameState) # Distancia real del state a una comida\\n if max < distance: # Cálculo del máximo\\n max = distance\\n return max\\n\\n # La siguiente heurística también servía, y de hecho tardaba mucho menos, pero el autograder me daba 2/4\\n # ya que se expandían más de 12.000 nodos.\\n # return len(foodGrid.asList())\",\n \"def a_star(start: Vector2D, goal: Vector2D, grid: Scene, heuristic: Callable[[Vector2D, Vector2D], float]) -> (list, list):\\n\\n\\n frontier = PriorityQueue() # nodes to be explored\\n expected_cost = heuristic(start, goal) # estimate of cost to reach goal from current node\\n\\n prev_node = dict() # maps n to node that precedes it in cheapest currently-known path from start to n\\n cost_so_far = dict() # maps n to cost of cheapest currently-known path from start to n\\n explored = [] # keeps track of previously explored nodes, to be drawn later\\n\\n frontier.put(start, expected_cost, expected_cost)\\n prev_node[start] = None\\n cost_so_far[start] = 0\\n\\n while not frontier.empty():\\n current = frontier.get()\\n\\n if current == goal: # solution found!\\n return (reconstruct_path(goal, prev_node), explored)\\n\\n explored.append(current)\\n\\n for neighbor in grid.get_unexplored_neighbors(current):\\n path_cost = cost_so_far[current] + grid.cost(neighbor) # cost of path to 'neighbor' going through 'current'\\n\\n if (neighbor not in cost_so_far) or (path_cost < cost_so_far[neighbor]): # if this path reaches node 'neighbor' faster than some previous path\\n cost_so_far[neighbor] = path_cost\\n expected_cost = heuristic(neighbor, goal)\\n priority = path_cost + expected_cost\\n frontier.put(neighbor, priority, expected_cost) # 'expected_cost' is used as a tie breaker to reduce paths to explore\\n\\n prev_node[neighbor] = current\\n\\n # If frontier empty but goal was never reached, no solution was found\\n return ([], explored)\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n visited = []\\n solution = []\\n intialCost = 0\\n priorityQueue = util.PriorityQueue()\\n priorityQueue.push((problem.getStartState(),solution,intialCost),intialCost)\\n \\n while not priorityQueue.isEmpty():\\n coord, solution, totalStep = priorityQueue.pop()\\n if problem.isGoalState(coord):\\n return solution\\n if not coord in visited:\\n visited+=[coord]\\n for position, direction, step in problem.getSuccessors(coord):\\n newSolution = solution+[direction]\\n g = totalStep + step\\n newTotalCost = g + heuristic(position, problem)\\n priorityQueue.push((position, newSolution, g), newTotalCost)\",\n \"def Find_Path(self):\\n closed_nodes_map = [] # map of closed (tried-out) nodes\\n open_nodes_map = [] # map of open (not-yet-tried) nodes\\n dir_map = [] # map of directions\\n row = [0] * self.n\\n for i in range(self.m): # create 2d arrays\\n closed_nodes_map.append(list(row))\\n open_nodes_map.append(list(row))\\n dir_map.append(list(row))\\n \\n pq = [[], []] # priority queues of open (not-yet-tried) nodes\\n pqi = 0 # priority queue index\\n # create the start node and push into list of open nodes\\n n0 = node(self.xStart, self.yStart, 0.0, 0.0)\\n n0.updatePriority(self.xFinish, self.yFinish)\\n heappush(pq[pqi], n0)\\n open_nodes_map[self.yStart][self.xStart] = n0.priority # mark it on the open nodes map\\n \\n # A* search\\n while len(pq[pqi]) > 0:\\n # get the current node w/ the highest priority\\n # from the list of open nodes\\n n1 = pq[pqi][0] # top node\\n n0 = node(n1.xPos, n1.yPos, n1.distance, n1.priority)\\n x = n0.xPos\\n y = n0.yPos\\n heappop(pq[pqi]) # remove the node from the open list\\n open_nodes_map[y][x] = 0\\n # mark it on the closed nodes map\\n closed_nodes_map[y][x] = 1\\n \\n # quit searching when the goal state is reached\\n if x == self.xFinish and y == self.yFinish:\\n # Generate the path from finish to start by following the \\n # directions.\\n return self.Reconstruct_Path(dir_map)\\n \\n # generate moves (child nodes) in all possible directions\\n for i in range(self.num_directions):\\n new_x = x + self.dx[i]\\n new_y = y + self.dy[i]\\n Flag=True\\n if not (new_x < 0 or new_x > self.n-1 or new_y < 0 or new_y > self.m - 1\\n or self.MAP[new_y][new_x] == 1 or closed_nodes_map[new_y][new_x] == 1):\\n # Check to see if the extended path runs through any obstacles\\n if (abs(self.dx[i])>1 or abs(self.dy[i])>1):\\n # Need to check that the path does not pass an object\\n JumpCells=2*max(abs(self.dx[i]),abs(self.dy[i]))-1\\n for K in range(1,JumpCells):\\n YPOS=int(round(K*1.0*self.dy[i]/JumpCells))\\n XPOS=int(round(K*1.0*self.dx[i]/JumpCells))\\n if (self.MAP[y+YPOS][x+XPOS]==1):\\n Flag=False\\n if Flag: \\n # generate a child node\\n m0 = node(new_x, new_y, n0.distance, n0.priority)\\n m0.calc_cost(self.dx[i], self.dy[i])\\n m0.updatePriority(self.xFinish, self.yFinish)\\n # if it is not in the open list then add into that\\n if open_nodes_map[new_y][new_x] == 0:\\n open_nodes_map[new_y][new_x] = m0.priority\\n heappush(pq[pqi], m0)\\n # mark its parent node direction\\n dir_map[new_y][new_x] = (self.num_directions-i-1) % self.num_directions\\n elif open_nodes_map[new_y][new_x] > m0.priority:\\n # update the priority info\\n open_nodes_map[new_y][new_x] = m0.priority\\n # update the parent direction info\\n dir_map[new_y][new_x] = (self.num_directions-i-1) % self.num_directions\\n # replace the node\\n # by emptying one pq to the other one\\n # except the node to be replaced will be ignored\\n # and the new node will be pushed in instead\\n while not (pq[pqi][0].xPos == new_x and pq[pqi][0].yPos == new_y):\\n heappush(pq[1 - pqi], pq[pqi][0])\\n heappop(pq[pqi])\\n heappop(pq[pqi]) # remove the wanted node\\n # empty the larger size pq to the smaller one\\n if len(pq[pqi]) > len(pq[1 - pqi]):\\n pqi = 1 - pqi\\n while len(pq[pqi]) > 0:\\n heappush(pq[1-pqi], pq[pqi][0])\\n heappop(pq[pqi]) \\n pqi = 1 - pqi\\n heappush(pq[pqi], m0) # add the better node instead\\n return '','' # no route found\",\n \"def astar(grid, heuristic):\\r\\n\\r\\n class MapNode:\\r\\n def __init__(self, cell, cost, parent):\\r\\n self.cell = cell\\r\\n self.cost = cost\\r\\n self.parent = parent\\r\\n\\r\\n @functools.total_ordering\\r\\n class FrontierElement:\\r\\n def __init__(self, cell, cost, parent, estimatedCost):\\r\\n self.node = MapNode(cell, cost, parent)\\r\\n self.estimatedCost = estimatedCost\\r\\n def __lt__(self, other):\\r\\n return self.estimatedCost < other.estimatedCost\\r\\n def __eq__(self, other):\\r\\n return self.estimatedCost is other.estimatedCost\\r\\n\\r\\n frontier = PriorityQueue()\\r\\n visitedNodes = set()\\r\\n frontier.put(FrontierElement(grid.getStart(), 0, None, 0))\\r\\n\\r\\n path = []\\r\\n\\r\\n while not frontier.empty():\\r\\n currentElement = frontier.get()\\r\\n grid.addVisited(currentElement.node.cell)\\r\\n visitedNodes.add(currentElement.node.cell)\\r\\n\\r\\n if currentElement.node.cell in grid.getGoals():\\r\\n currentNode = currentElement.node\\r\\n while currentNode is not None:\\r\\n path.insert(0, currentNode.cell)\\r\\n currentNode = currentNode.parent\\r\\n break\\r\\n\\r\\n for neighbor in grid.getNeighbors(currentElement.node.cell):\\r\\n neighborCoord = neighbor[0]\\r\\n\\r\\n if neighborCoord in visitedNodes:\\r\\n continue\\r\\n\\r\\n neighborCost = neighbor[1]\\r\\n cheapestGoal = min(grid.getGoals(), key=lambda goal: Vector2.fromCell(neighborCoord).squaredDistanceTo(Vector2.fromCell(goal)))\\r\\n\\r\\n cost = currentElement.node.cost + neighborCost\\r\\n\\r\\n frontier.put(FrontierElement(neighborCoord, cost, currentElement.node, cost + heuristic(neighborCoord, cheapestGoal)))\\r\\n\\r\\n grid.setPath(path)\",\n \"def solve_environment(self):\\n \\n #The first problem formulation\\n #K kinds of towers\\n #See more details about problem formulation in the writeup \\n \\n #Get a full matrix of the concatenated coverage matrices for \\n #each tower type. THis new matrix has dimensions:\\n #(Ntowers) x (sum(potential sites)), where the sum o=is over all tower types\\n coverage = np.hstack(i for i in self.coverage_matrices)\\n print coverage\\n print coverage.shape \\n \\n #Diagonal matrix of the values of each target\\n #(for the scenarios where we don't care about maximizing covered value,\\n #target_values is just all ones, so this is just the identity matrix)\\n V = np.diag(self.target_values)\\n \\n #If doing scenario where we want to fortify weakest link, only makes\\n #sense if all targets are equal value:\\n if self.objective_type == 'min_entries':\\n V = np.eye(len(self.target_values))\\n\\n #Get the matrix of coverage values / expected value saved:\\n C = np.dot(V,coverage)\\n print 'V', V\\n print 'coverage', coverage\\n print 'C', C\\n \\n \\n #Since not gauranteed to reach global optimum on any particular initialization,\\n #run a few times and take the best result.\\n #Just define \\\"best result\\\" as the result which had the most overall \\n #\\\"converged\\\" x, combined over all tower kinds. \\n# for j in xrange(self.N_random_starts_max):\\n \\n \\n a = 2. #1.\\n tau = 1e-4\\n N = sum(i for i in self.N_tower_sites)\\n w = np.zeros(N)\\n ones = np.ones(N)\\n p = 1. #the exponents power when doing he exponent method:\\n \\n for i in xrange(self.N_reweighting_iterations_max):\\n #The concatenated vector of occupancies: Concatenated over all\\n #of the kinds of towers.\\n x = cvx.Variable(N)\\n \\n #Different objective functions depending on which optimization problem.\\n #These are defined in the scenarios in the main function.\\n if self.objective_type == 'min_entries':\\n operation = cvx.min_entries\\n elif self.objective_type == 'sum_entries':\\n operation = cvx.sum_entries\\n else:\\n raise Exception('must specify valid objective_type')\\n \\n #Objective function includes penalty term for non-binary x values\\n if self.penalty_type == 'reweighted_L1':\\n #objective = cvx.Maximize(t - x.T*w)\\n objective = cvx.Maximize(operation(C*x - x.T*w))\\n\\n\\n #Main constraints on 0<=x<=1\\n constraints = [0<=x, x<=1]\\n \\n \\n #And then for each kind of tower, append the constraint that there\\n #be exactly N_i towers, or <= quota (depending on constraint type)\\n if self.constraints__type == 'fixed_N_towers' or self.constraints__type == 'tower_quotas':\\n for tk in xrange(self.N_tower_kinds):\\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\\n print before_sum\\n print before_sum + self.N_tower_sites[tk]\\n if self.constraints__type == 'fixed_N_towers':\\n constraints.append(cvx.sum_entries(\\n x[before_sum : before_sum + self.N_tower_sites[tk]]\\n )==self.N_towers[tk])\\n elif self.constraints__type == 'tower_quotas':\\n constraints.append(cvx.sum_entries(\\n x[before_sum : before_sum + self.N_tower_sites[tk]]\\n )<=self.budget__tower_quotas[tk])\\n print x[before_sum : before_sum + self.N_tower_sites[tk]]\\n \\n elif self.constraints__type == 'total_cost':\\n costs = np.hstack([np.repeat(self.budget__tower_unit_costs[tk],self.N_tower_sites[tk]) for tk in xrange(self.N_tower_kinds)])\\n constraints.append(cvx.sum_entries(costs * x) <= self.budget__total_cost) \\n \\n \\n \\n\\n\\n \\n \\n print 'penalty_type', self.penalty_type\\n print 'objective_type', self.objective_type\\n print 'constraints__type', self.constraints__type\\n print 'budget__tower_quotas', self.budget__tower_quotas\\n print 'operation', operation\\n print 'objective', objective\\n print 'constraints', constraints\\n cvx.Problem(objective, constraints).solve(verbose=self.VERBOSE)\\n x = np.array(x.value).flatten()\\n print 'x', x\\n w = a/(tau+np.abs(x))\\n p += 1.\\n plt.figure(figsize=(5,5))\\n plt.plot(x,marker='o')\\n plt.savefig('histrograms_{}.png'.format(i))\\n print \\n \\n \\n \\n \\n #From the solution x, get the coordinates of those tower sites where we\\n #really do want to place a tower\\n #use = np.isclose(x,1.)\\n for tk in xrange(self.N_tower_kinds):\\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\\n y = x[before_sum : before_sum + self.N_tower_sites[tk]]\\n inds = np.argsort(y)\\n s = y[inds]\\n use = np.where(s>.5)[0]\\n print inds\\n print s\\n print use \\n if self.constraints__type == 'fixed_N_towers':\\n if len(use) != self.N_towers[tk]:\\n print 'Solution did not converge properly. Choosing the K best towers.'\\n print self.N_towers[tk], len(use)\\n # use = use[-self.N_towers[tk]:]\\n use = inds[-self.N_towers[tk]:]\\n elif self.constraints__type == 'tower_quotas':\\n pass #Just use the towers thresholded at > .5\\n print use\\n \\n \\n self.coordinates__solved_towers.append([self.coordinates__tower_sites[tk][mm] for mm in inds[use]])\",\n \"def astar(grid, heuristic):\\r\\n evaluatedMap = {}\\r\\n unevaluatedMap = {}\\r\\n start = grid.getStart()\\r\\n goal = grid.getGoals()[0]\\r\\n startG = 0\\r\\n startH = heuristic(start,goal)\\r\\n currentNode = Node(start,startH,startG)\\r\\n unevaluatedMap[currentNode.coord] = currentNode\\r\\n \\r\\n while len(unevaluatedMap) > 0:\\r\\n # I tried using a PriorityQueue but because a node could end up with \\r\\n # an updated priority it really didn't make sense to use one and\\r\\n # instead had to just serach the dictionary each time for the smallest\\r\\n # priority which is the sum of g and h\\r\\n currentNode = min(unevaluatedMap.values(),key=lambda x:x.g + x.h)\\r\\n \\r\\n # if the current node is the goal then create the path by iterating backwards\\r\\n # and pushing the current node to the front of the path and then moving to the\\r\\n # parent node\\r\\n if currentNode.coord == goal:\\r\\n path = []\\r\\n while currentNode.parentNode:\\r\\n path.insert(0,currentNode.coord)\\r\\n currentNode = currentNode.parentNode\\r\\n path.insert(0,currentNode.coord)\\r\\n grid.setPath(path)\\r\\n return\\r\\n \\r\\n # Move the current node to the evaluated map and delete it from\\r\\n # the unevaluated map\\r\\n evaluatedMap[currentNode.coord] = currentNode\\r\\n del unevaluatedMap[currentNode.coord]\\r\\n \\r\\n # Mark the current node as having been visited\\r\\n grid.addVisited(currentNode.coord)\\r\\n \\r\\n # Get the neighbors of the current node\\r\\n neighbors = grid.getNeighbors(currentNode.coord)\\r\\n\\r\\n # For each neighbor check if that neighbor has alread been evaluated\\r\\n # if it has then skip that neighbor. If it hasn't and it isn't in the\\r\\n # unevaluated map add it with a high cost and heuristic.\\r\\n # Get the neighbor from the unevaluated map and calculate the current\\r\\n # cost. If the current cost is less than what existed update the neighbor\\r\\n # and add it back to the list otherwise skip to next neighbor\\r\\n for neighbor in neighbors:\\r\\n ncoord = (neighbor[0])\\r\\n if (ncoord) in evaluatedMap:\\r\\n continue\\r\\n if (ncoord) not in unevaluatedMap:\\r\\n node = Node(ncoord,float('inf'),float('inf'))\\r\\n unevaluatedMap[ncoord] = node\\r\\n \\r\\n node = unevaluatedMap[ncoord]\\r\\n calc_cost = currentNode.g + neighbor[1]\\r\\n if calc_cost >= node.g:\\r\\n continue\\r\\n \\r\\n node.parentNode = currentNode\\r\\n node.g = calc_cost\\r\\n node.h = heuristic(ncoord,goal)\",\n \"def initialisationTurn(mazeWidth, mazeHeight, mazeMap, preparationTime, turnTime, playerLocation, opponentLocation, coins) :\\n global route_table, packages, best_weight, best_path, route\\n fill_packages(coins)\\n current_package = packages.pop(0)\\n exhaustive(current_package, playerLocation, [], 0, (route_table,dists))\\n api.debug(best_path)\",\n \"def spotlessroomba_second_heuristic(state : SpotlessRoombaState) -> float:\\n # TODO a nontrivial consistent heuristic\\n \\n if not state.dirty_locations:\\n return 0\\n \\n best_start = 0 # best dirty tile to start from\\n best_cost = INF # cost of the path from the above start tile\\n\\n for i in range(len(state.dirty_locations)):\\n estimate_cost = 0\\n lowest_cost = INF\\n closest_dirty = 0\\n dirty_locations = list(state.dirty_locations)\\n current_pos = dirty_locations.pop(i)\\n\\n # find the shortest cost solution path from this starting tile\\n while dirty_locations:\\n for j in range(len(dirty_locations)):\\n manhattan = abs(current_pos.row - dirty_locations[j].row) + abs(current_pos.col - dirty_locations[j].col)\\n if manhattan < lowest_cost:\\n lowest_cost = manhattan\\n closest_dirty = j\\n estimate_cost += lowest_cost\\n current_pos = dirty_locations.pop(closest_dirty)\\n lowest_cost = INF\\n # if estimated path cost is cheaper than best path cost so far, replace best_cost and best_start\\n if estimate_cost < best_cost:\\n best_cost = estimate_cost\\n best_start = i\\n # if estimated path cost and best path cost so far are equal, tiebreak with proximity to start tile\\n if estimate_cost == best_cost:\\n current_pos = state.position\\n dist_to_prev_best = abs(current_pos.row - state.dirty_locations[best_start].row) + abs(current_pos.col - state.dirty_locations[best_start].col)\\n dist_to_i = abs(current_pos.row - state.dirty_locations[i].row) + abs(current_pos.col - state.dirty_locations[i].col)\\n if dist_to_i < dist_to_prev_best:\\n best_start = i\\n \\n\\n current_pos = state.position\\n # Calculate distance to the best start tile\\n dist_to_start = abs(current_pos.row - state.dirty_locations[best_start].row) + abs(current_pos.col - state.dirty_locations[best_start].col)\\n # Returned heuristic is the sum of distance to the start tile and estimated cost from said tile\\n return dist_to_start + best_cost\",\n \"def get_pathologic_covering_routes(n_pl, n_target, attacker_strategy, target_values):\\n # computes the coefficient used by the greedy oracle to choose routes\\n targets_coeff = np.transpose(np.multiply(attacker_strategy, target_values))\\n\\n # randomly selects the player for which the non optimal choice will be made\\n wrong_pl = randint(1, n_pl)\\n\\n # generate the non optimal route randomly\\n n_covered_targets = randint(n_pl,n_target-1)\\n non_opt_action = np.zeros(n_target)\\n for i in range(0, n_covered_targets):\\n random_covered_target = randint(0, n_target-1)\\n non_opt_action[random_covered_target] = 1\\n\\n # compute the value of the non optimal route\\n non_opt_val = get_value_single_route(non_opt_action, targets_coeff)\\n\\n # generate routes that have, as a single, values smaller than the best greedy route but taken togher perform\\n # at least as well. [[0,1,...],[...],...] a[r][t]=1 iff t is covered by r.\\n # The returned list should have n_pl - 1 routes\\n opt_routes = get_opt_routes(n_pl, non_opt_action)\\n\\n I={}\\n for pl in range(1, n_pl+1):\\n\\n n_r = randint(0, MAX_ROUTES)\\n temp = lil_matrix((n_r+1, n_target), dtype='int8')\\n\\n if pl == wrong_pl:\\n # put the non opt route in the bucket\\n for t in non_opt_action.nonzero():\\n temp[0,t] = 1\\n else:\\n for t in opt_routes.pop().nonzero():\\n temp[0,t] = 1\\n\\n # generate other random routes with single value less than the non_opt_value\\n for r in range(1, n_r):\\n new_route = get_r_limited_val(non_opt_val, targets_coeff)\\n\\n for t in new_route.nonzero():\\n temp[r,t] = 1\\n\\n I[pl] = temp.tocsr()\\n\\n return I\",\n \"def shortJourney(Alist,s,d):\\n \\\"\\\"\\\"Find shortest distances to s in weighted graph, G\\\"\\\"\\\"\\n \\n #Initialize dictionaries\\n dinit = 10**6\\n Edict = {} #Explored nodes\\n Udict = {} #Unexplored nodes\\n path = [[] for l in Alist]\\n\\n Alen = len(Alist) #length of Alist\\n dinits = [dinit]*Alen #list of airport indexes\\n Udict = dict(zip(list(range(Alen)),dinits)) #zip into dictionary\\n Udict[s] = 0\\n path[s] = [s]\\n \\n #Main search\\n while len(Udict)>0:\\n #Find node with min d in Udict and move to Edict\\n dmin = dinit\\n for n,w in Udict.items():\\n if w<dmin:\\n dmin=w\\n nmin=n\\n Edict[nmin] = Udict.pop(nmin)\\n print(\\\"moved node\\\", nmin)\\n\\n #Update provisional distances for unexplored neighbors of nmin \\n for item in Alist[nmin]: #nminth element is a list of two element tuples (node, weight)\\n n = item[0] #first elt of tuple is node/neighbour\\n w = item[1] #2nd elt is density/weigh\\n #for n,w in etc_______________________-\\n \\n if n in Edict:\\n pass\\n elif n in Udict:\\n #key difference below\\n dcomp = (w+dmin) #take sum as you go along\\n if dcomp<Udict[n]:\\n print(Udict)\\n Udict[n]=dcomp\\n path[n] = path[nmin] + [n]\\n print(path) \\n if nmin == d: #if current node is destination\\n return [path[d],Edict[d]]\\n return [] #no path\",\n \"def original_solution():\\n matrix = get_data()\\n # Construct Graph\\n G = nx.DiGraph()\\n rows, cols = len(matrix), len(matrix[0])\\n for r in xrange(rows):\\n for c in xrange(cols):\\n if 0 < c:\\n G.add_edge(r*cols + c, r*cols + c - 1, weight=matrix[r][c-1])\\n if c < cols-1:\\n G.add_edge(r*cols + c, r*cols + c + 1, weight=matrix[r][c+1])\\n if 0 < r:\\n G.add_edge(r*cols + c, (r-1)*cols + c, weight=matrix[r-1][c])\\n if r < rows-1:\\n G.add_edge(r*cols + c, (r+1)*cols + c, weight=matrix[r+1][c])\\n # Calculate shortest path\\n path = nx.shortest_path(G, 0, rows*cols-1, weighted=True)\\n \\n # Get cost for path\\n s = 0\\n for p in path:\\n c = p % cols\\n r = (p - c) / rows\\n s += matrix[r][c]\\n return s\",\n \"def greedy_selector(self):\\n r_k = 0 \\n best_route = []\\n cities_to_visit = [i for i in range(1, self.city_count)]\\n for _ in range(1, self.city_count):\\n s_ind = np.argmax([self.tau[(r_k, u)] for u in cities_to_visit])\\n s_k = cities_to_visit.pop(s_ind)\\n best_route.append((r_k, s_k))\\n r_k = s_k\\n best_route.append((r_k, 0))\\n \\n shortest_path = np.sum([self.phi[(p)] for p in best_route])\\n return best_route, shortest_path\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n #Creamos las estructuras de datos necesarias (priority queue y set)\\n openNodes = util.PriorityQueue()\\n closedNodes = set([])\\n\\n #Guardamos el nodo inicial\\n node = Node(problem.getStartState(), '', 0, None)\\n\\n #Calculamos funcion heuristica y el coste acumulado para sacar la funcion de evaluacion del nodo inicial\\n fn = problem.getCostOfActions(node.path) + heuristic(node.name, problem);\\n\\n #Lo metemos en la cola con su funcion de evaluacion como prioridad\\n openNodes.push(node, fn)\\n\\n #Iteramos para cada nodo\\n while True:\\n if openNodes.isEmpty():\\n break #ERROR: throw exception\\n else :\\n #sacamos el nodo de arriba de la cola\\n node = openNodes.pop()\\n if problem.isGoalState(node.name): #Comprobamos si el nodo es Goal. Si lo es terminamos.\\n break\\n else: #Expandimos los nodos sucesores del nodo si no estan en closed\\n if nodeIsClosed(node, closedNodes) is False:\\n for successor in problem.getSuccessors(node.name):\\n n, p, c = successor\\n succNode = Node(n, p, c, node)\\n if nodeIsClosed(succNode, closedNodes) is False:\\n fn = problem.getCostOfActions(findPath(succNode)) + heuristic(succNode.name, problem);\\n openNodes.push(succNode, fn)\\n #Metemos el nodo en closed\\n closedNodes.add(node)\\n\\n #Devolvemos el camino al Goal\\n return findPath(node)\",\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 a_star(self, start, final):\\n self.speed_setting_season()\\n cost_so_far = {}\\n frontier = PriorityQueue()\\n parents = {}\\n frontier.put(start, 0)\\n cost_so_far[start] = 0\\n f_value = {}\\n f_value[start] = self.grid.heuristic(start[0], start[1], final[0], final[1])\\n final_path_list = []\\n while not frontier.empty():\\n actual_node = frontier.get()\\n final_path_list = []\\n if actual_node == final:\\n curr = final\\n while curr != start:\\n final_path_list.insert(0, curr)\\n curr = parents[curr]\\n final_path_list.insert(0, start)\\n break\\n potential_neighbors = self.grid.neighbors(int(actual_node[0]), int(actual_node[1]))\\n for neighbor in potential_neighbors:\\n g_value = cost_so_far[actual_node] + self.grid.cost_g(actual_node[0], actual_node[1],\\n neighbor[0],\\n neighbor[1])\\n h_value = self.grid.heuristic(neighbor[0], neighbor[1], final[0], final[1])\\n if neighbor not in cost_so_far or g_value + h_value < f_value[neighbor]:\\n cost_so_far[neighbor] = g_value\\n f_value[neighbor] = g_value + h_value\\n frontier.put(neighbor, g_value + h_value)\\n parents[neighbor] = actual_node\\n print(\\\"found path from: \\\" + str(start) + \\\" to: \\\" + str(final))\\n return final_path_list\",\n \"def problem5(self, s):\\n points = 0\\n\\n points = self.neighbor( 10, 10, s.nearest_neighbor)*3\\n points += self.neighbor(100, 10, s.nearest_neighbor)*3\\n points += self.neighbor( 10, 100, s.nearest_neighbor)*3\\n points += self.neighbor(100, 100, s.nearest_neighbor)*3\\n points += self.neighbor(100, 100, s.nearest_neighbor)*3\\n\\n _testDriver.get_code(s.nearest_neighbor)\\n print \\\"\\\\n(Check that scipy.spatial.KDTree is not used)\\\"\\n points *= self.grade(1)\\n \\n return points\",\n \"def anneal(solution):\\n old_cost = cost(solution)\\n T = 1.0\\n T_min = 0.00001\\n ALPHA = 0.9\\n\\n while T > T_min:\\n i = 1\\n while i <= 100:\\n new_solution = neighbor(solution)\\n new_cost = cost(new_solution)\\n ap = acceptance_probability(old_cost, new_cost, T)\\n if ap > random.random():\\n solution = new_solution\\n old_cost = new_cost\\n i += 1\\n T = T * ALPHA\\n\\n return solution, old_cost\",\n \"def a_star_search(problem, heuristic=null_heuristic):\\r\\n \\\"*** YOUR CODE HERE ***\\\"\\r\\n fringe = util.PriorityQueue()\\r\\n path = set()\\r\\n final = []\\r\\n acts = dict()\\r\\n state = problem.get_start_state()\\r\\n fringe.push(state, 0)\\r\\n\\r\\n while (True):\\r\\n state = fringe.pop()\\r\\n path.add(state)\\r\\n states = problem.get_successors(state)\\r\\n acts[state] = states[:]\\r\\n if problem.is_goal_state(state):\\r\\n break\\r\\n\\r\\n states = problem.get_successors(state)\\r\\n # push into fringe\\r\\n for stat in states:\\r\\n if stat[0] not in path:\\r\\n \\\"\\\"\\\"\\r\\n it does worse in corners problems, to work better needs heavy huristic, not worth in\\r\\n in corners problem expandend nodes grow expo\\r\\n all others are better\\r\\n counter = 0 # in some situation it helps, in some it doesnt\\r\\n #print(stat[0].pieces)\\r\\n for x in stat[0].pieces[0]:\\r\\n if x:\\r\\n counter += 1\\r\\n \\\"\\\"\\\"\\r\\n counter = 0\\r\\n fringe.push(stat[0], stat[2] + counter + heuristic(stat[0], problem)) # problem.get_cost_of_actions([stat[1]])\\r\\n\\r\\n while (True):\\r\\n\\r\\n for key, val in acts.items():\\r\\n for va in val:\\r\\n if va[0] == state:\\r\\n final.append(va[1])\\r\\n state = key\\r\\n break\\r\\n else:\\r\\n continue\\r\\n break\\r\\n if state == problem.get_start_state():\\r\\n break\\r\\n\\r\\n final.reverse()\\r\\n\\r\\n return final\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE ***\\\"\\n class Node:\\n def __init__(self, state, parent, action, pathCost):\\n self.state = state\\n self.parent = parent\\n self.action = action\\n self.pathCost = pathCost\\n\\n def solution(self):\\n path = list()\\n tempNode = self\\n while tempNode.state != problem.getStartState():\\n path.insert(0, tempNode.action)\\n tempNode = tempNode.parent\\n return path\\n\\n def __eq__(self, other):\\n if isinstance(other, Node):\\n return self.state == other.state\\n\\n\\n def childNode(successor, parent, action, stepCost):\\n pathCost = parent.pathCost + stepCost\\n child = Node(successor, parent, action, pathCost)\\n return child\\n\\n initialNode = Node(problem.getStartState(), None, None, 0)\\n frontier = util.PriorityQueue() #bfs uses a queue\\n frontier.push(initialNode, initialNode.pathCost + heuristic(initialNode.state, problem)) #we use f(n) = pathCost + h(n) for the best solution\\n explored = set()\\n\\n while not frontier.isEmpty() :\\n nextNode = frontier.pop() #extract from the start of the queue\\n if problem.isGoalState(nextNode.state):\\n return nextNode.solution()\\n explored.add(nextNode.state)\\n for successor, action, stepCost in problem.getSuccessors(nextNode.state):\\n child = childNode(successor, nextNode, action, stepCost)\\n if child.state not in explored:\\n frontier.update(child, child.pathCost + heuristic(child.state, problem))\\n return []\\n util.raiseNotDefined()\",\n \"def find_solution(self):\\n print(\\\"\\\\nFinding ICTS Solution...\\\")\\n ######### Fill in the ICTS Algorithm here #########\\n result = self.stat_tracker.time(\\\"time\\\", lambda: self.bfs())\\n if result == -1:\\n self.stat_tracker.stats['time'] = -1\\n return []\\n self.stat_tracker.write_stats_to_file(self.stat_tracker.get_results_file_name())\\n return result\\n ###################################################\",\n \"def TSP(noOfCities, cityIndicesExcluding1, citiesDistance):\\r\\n\\r\\n # Initializing the DP Matrix\\r\\n # Dictionary because the subset is also to be saved alongwith end vertex as index of dictionary\\r\\n dpMatrixDict = {}\\r\\n\\r\\n # Base case\\r\\n dpMatrixDict[ ( 1, ), 1 ] = 0\\r\\n\\r\\n # Iterating to solve bigger subproblems using dynamic programming\\r\\n for subsetSizeWithout1 in range(1, noOfCities):\\r\\n\\r\\n # Subset is of size subsetSizeWithout1 + 1\\r\\n print(\\\"COMPUTING. ON ITERATION NUMBER : \\\" + str(subsetSizeWithout1) + \\\" OUT OF \\\" + str(noOfCities - 1) )\\r\\n\\r\\n # Reducing computation by ignoring off the smaller subproblems solutions no longer required\\r\\n if subsetSizeWithout1 > 3:\\r\\n smallerEfficientDpMatrixDict = {}\\r\\n for key in dpMatrixDict:\\r\\n if len(key[0]) == subsetSizeWithout1:\\r\\n smallerEfficientDpMatrixDict[key] = dpMatrixDict[key]\\r\\n dpMatrixDict = smallerEfficientDpMatrixDict\\r\\n\\r\\n # Getting the subsets reuired\\r\\n sizeSpecificSubsets = getSubsets(cityIndicesExcluding1, subsetSizeWithout1)\\r\\n\\r\\n # Base cases\\r\\n for subset in sizeSpecificSubsets:\\r\\n dpMatrixDict[subset, 1] = 99999999\\r\\n\\r\\n\\r\\n for subset in sizeSpecificSubsets:\\r\\n\\r\\n # Computing through each possible end vertex\\r\\n for j in subset[1:]:\\r\\n\\r\\n # List to store the candidates for minimums\\r\\n possibilities = []\\r\\n\\r\\n # Computing through each possible last hop\\r\\n for k in subset:\\r\\n\\r\\n # Storing possibilities alongwith the end vertex\\r\\n if k != j:\\r\\n tupleCopy = tupleCopyWithoutElement(subset, j)\\r\\n possibilities.append( dpMatrixDict[tupleCopy, k] + citiesDistance[k, j] )\\r\\n\\r\\n # Getting the minimum path from the possible minimum candidates\\r\\n try:\\r\\n minimumPath = min(possibilities)\\r\\n dpMatrixDict[subset, j] = minimumPath\\r\\n except:\\r\\n continue\\r\\n\\r\\n\\r\\n # List for storing all final possible path candidates containing all the vertices\\r\\n # and a last hop between the start and end vertex to make a cycle\\r\\n finalHamiltonianPathCandidates = []\\r\\n\\r\\n # Final Set(and/or Subset) including all the vertices\\r\\n almostCompletePath = tuple(range(1, noOfCities + 1))\\r\\n\\r\\n # Adding the last hop of the cycle of hamiltonian path between the end and start vertex\\r\\n for j in cityIndicesExcluding1:\\r\\n finalHamiltonianPathCandidates.append( dpMatrixDict[almostCompletePath, j] + citiesDistance[j, 1] )\\r\\n\\r\\n # Getting the final minimum solution\\r\\n hamiltonianPathSolution = min(finalHamiltonianPathCandidates)\\r\\n\\r\\n # Printing the solution\\r\\n print(\\\"The optimal(minimum) length Hamiltonian path distance is : \\\" + str( hamiltonianPathSolution ) )\\r\\n\\r\\n return\",\n \"def solve(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix, params=[]):\\n locations = student_utils.convert_locations_to_indices(list_of_locations, list_of_locations)\\n homes = student_utils.convert_locations_to_indices(list_of_homes, list_of_locations)\\n start = list_of_locations.index(starting_car_location)\\n\\n start_time = time.time()\\n\\n if params[0] == 'naive':\\n car_path, drop_off = naive_solver(locations, homes, start, adjacency_matrix)\\n print(\\\"--- %s seconds ---\\\" % (time.time() - start_time))\\n return car_path, drop_off\\n elif params[0] == 'greedy':\\n car_path, drop_off = greedy_solver(locations, homes, start, adjacency_matrix)\\n print(\\\"--- %s seconds ---\\\" % (time.time() - start_time))\\n return car_path, drop_off\\n elif params[0] == 'three_opt':\\n car_path, drop_off = three_opt_solver(locations, homes, start, adjacency_matrix)\\n print(\\\"--- %s seconds ---\\\" % (time.time() - start_time))\\n return car_path, drop_off\\n elif params[0] == 'ant_colony':\\n car_path, drop_off = ant_colony(locations, homes, start, adjacency_matrix)\\n print(\\\"--- %s seconds ---\\\" % (time.time() - start_time))\\n return car_path, drop_off\\n elif params[0] == 'greedy_clustering_three_opt':\\n car_path, drop_off = greedy_clustering_three_opt(locations, homes, start, adjacency_matrix, int(params[1]))\\n print(\\\"--- %s seconds ---\\\" % (time.time() - start_time))\\n return car_path, drop_off\\n elif params[0] == 'mst':\\n car_path, drop_off = mst_solver(locations, homes, start, adjacency_matrix)\\n print(\\\"--- %s seconds ---\\\" % (time.time() - start_time))\\n return car_path, drop_off\\n elif params[0] == 'two_opt':\\n car_path, drop_off = two_opt_solver(locations, homes, start, adjacency_matrix)\\n print(\\\"--- %s seconds ---\\\" % (time.time() - start_time))\\n return car_path, drop_off\\n elif params[0] == 'greedy_clustering_two_opt':\\n car_path, drop_off = greedy_clustering_two_opt(locations, homes, start, adjacency_matrix, int(params[1]))\\n print(\\\"--- %s seconds ---\\\" % (time.time() - start_time))\\n return car_path, drop_off\\n else:\\n pass\",\n \"def optimize(self):\\n self.check_is_ready()\\n self.check_infeasibility()\\n solution_graph, obj_val = self.find_shortest_network_with_ADH((self.old_network_graph is not None))\\n self.solution_graph = gnx.GeoMultiGraph(solution_graph, crs=self.optimization_graph.crs)\",\n \"def solve_maze(self):\\n initial_maze_loc = self.maze.location\\n curr_coord = initial_maze_loc\\n solution_path_directions = []\\n #print(\\\"in solve_maze:\\\")\\n\\n # The agent always chooses the next location with the highest Q value.\\n # With this strategy, the agent aims to reach the goal using the\\n # most optimal path possible.\\n while (self.grid[curr_coord[0]][curr_coord[1]] != 'G' and\\n self.grid[curr_coord[0]][curr_coord[1]] != 'E'):\\n possible_moves = self.maze.moves()\\n\\n # Find the next best move.\\n best_next_move = (0,0)\\n best_next_move_q = float('-inf')\\n for move in possible_moves:\\n if self.qtable[curr_coord[0]+move[0]][curr_coord[1]+move[1]] >= best_next_move_q:\\n best_next_move = move\\n best_next_move_q = self.qtable[curr_coord[0]+move[0]][curr_coord[1]+move[1]]\\n\\n direction = self.maze.moves_to_dirs[best_next_move]\\n solution_path_directions.append(direction)\\n curr_coord = (curr_coord[0]+best_next_move[0], curr_coord[1]+best_next_move[1])\\n self.maze.location = curr_coord\\n self.maze.location = initial_maze_loc # reset maze location to initial coord.\\n\\n return solution_path_directions\",\n \"def solve_maze(self):\\r\\n # if there is no maze to solve, cut the method\\r\\n if not self.generated:\\r\\n return None\\r\\n\\r\\n # initialize with empty path at starting cell\\r\\n self.path = dict()\\r\\n current = self.start\\r\\n\\r\\n # loop until the ending cell is reached\\r\\n while True:\\r\\n while True:\\r\\n # choose valid direction\\r\\n # must remain in the grid\\r\\n # also must not cross a wall\\r\\n dirNum = random.randint(0,3)\\r\\n adjacent = self.get_next_cell(current,dirNum,1)\\r\\n if self.is_valid_direction(current,dirNum):\\r\\n hasWall = (self.grid[adjacent[0]][adjacent[1]] == 0)\\r\\n if not hasWall:\\r\\n break\\r\\n # add cell and direction to path\\r\\n self.path[current] = dirNum\\r\\n\\r\\n # get next cell\\r\\n current = self.get_next_cell(current,dirNum,2)\\r\\n if current == self.end: \\r\\n break # break if ending cell is reached\\r\\n\\r\\n # go to start of path\\r\\n current = self.start\\r\\n self.solution.append(current)\\r\\n # loop until end of path is reached\\r\\n while not (current == self.end):\\r\\n dirNum = self.path[current] # get direction\\r\\n # add adjacent and crossed cells to solution\\r\\n crossed = self.get_next_cell(current,dirNum,1)\\r\\n current = self.get_next_cell(current,dirNum,2)\\r\\n self.solution.append(crossed)\\r\\n self.solution.append(current)\\r\\n\\r\\n self.path = dict()\",\n \"def solve_tsp(dist):\\n\\n # number of nodes\\n N = dist.shape[0]\\n\\n # tsp path for quick calculation of cost\\n ii = np.arange(N)\\n jj = np.hstack((np.arange(1, N), 0))\\n\\n # for each node, a sorted list of closest nodes\\n dsort = [np.argsort(d) for d in dist]\\n dsort = [d[d != i] for i, d in enumerate(dsort)]\\n\\n # randomly initialize path through graph\\n path = np.random.permutation(N)\\n idx = np.argsort(path)\\n cost = np.sum(dist[path[ii], path[jj]])\\n \\n # keep track of objective function over time\\n cost_hist = [cost]\\n\\n # optimization loop\\n node = 0\\n while node < N:\\n\\n # we'll try breaking the connection i -> j\\n i = path[node]\\n j = path[(node+1) % N]\\n \\n # since we are breaking i -> j we can remove the cost of that connection\\n c = cost - dist[i, j]\\n\\n # search over nodes k that are closer to j than i\\n for k in dsort[j]:\\n # can safely continue if dist[i,j] < dist[k,j] for the remaining k\\n if k == i:\\n node += 1\\n break\\n\\n # break connection k -> p\\n # add connection j -> p\\n # add connection i -> k\\n p = path[(idx[k]+1) % N]\\n new_cost = c - dist[k,p] + dist[j,p] + dist[i,k]\\n\\n # if this swap improves the cost, implement it and move to next i\\n if new_cost < cost:\\n path = reverse_segment(path, idx[j], idx[k])\\n idx = np.argsort(path)\\n # make sure that we didn't screw up\\n assert np.abs(np.sum(dist[path[ii], path[jj]]) - new_cost) < 1e-6\\n cost = new_cost\\n # restart from the begining of the graph\\n cost_hist.append(cost)\\n node = 0\\n break\\n\\n return path, cost_hist\",\n \"def safeJourney(Alist,s,d):\\n #Initialize dictionaries\\n dinit = 10**6\\n Edict = {} #Explored nodes\\n Udict = {} #Unexplored nodes\\n path = [[] for l in Alist]\\n\\n Alen = len(Alist) #length of Alist\\n dinits = [dinit]*Alen #list of airport indexes\\n Udict = dict(zip(list(range(Alen)),dinits)) #zip into dictionary\\n Udict[s] = 0\\n path[s] = [s]\\n \\n #Main search\\n while len(Udict)>0:\\n #Find node with min d in Udict and move to Edict\\n dmin = dinit\\n for n,w in Udict.items():\\n if w<dmin:\\n dmin=w\\n nmin=n\\n Edict[nmin] = Udict.pop(nmin)\\n print(\\\"moved node\\\", nmin)\\n\\n #Update provisional distances for unexplored neighbors of nmin\\n \\n #for n,w in G.adj[nmin].items():\\n for item in Alist[nmin]: #nminth element is a list of two element tuples (node, weight)\\n n = item[0] #first elt of tuple is node/neighbour\\n w = item[1] #2nd elt is density/weigh\\n #for n,w in etc_______________________-\\n \\n if n in Edict:\\n pass\\n elif n in Udict:\\n #dcomp = dmin + w\\n dcomp = max(w,dmin) #take largest value to record most dangerous segment\\n if dcomp<Udict[n]:\\n print(Udict)\\n Udict[n]=dcomp\\n path[n] = path[nmin] + [n]\\n #path[n].extend(path[nmin])\\n #path[n] = path[nmin]\\n \\n #path[n].append(n) #n not nmin\\n print(path)\\n # else:\\n #dcomp = dmin + w\\n # dcomp = max(w,dmin)\\n # Udict[n] = dcomp\\n #path[n].extend(path[nmin])\\n #path[n].append(nmin) \\n \\n if nmin == d: #if current node is destination\\n return path[d],Edict[d]\\n return [] #no path\",\n \"def hillClimbingSearch_RR(problem, p, maxSteps, userInteraction, beQuiet):\\n\\n import random\\n currentState = problem.state\\n if not beQuiet:\\n problem.visualize(currentState)\\n steps = 0\\n restarts=0\\n bestYet = currentState\\n\\n # for visualization\\n problem.hVals.append(problem.getObjValue(currentState))\\n\\n while steps<maxSteps:\\n if problem.isGlobalOptimum(currentState):\\n print(f\\\"\\\\nTotal random restarts done: {restarts}.\\\")\\n return steps, bestYet\\n if random.random()>=p:\\n # make a greedy step\\n neighbours = problem.getNeighbours(currentState)\\n runningBest = currentState\\n for n in neighbours:\\n nObjVal = problem.getObjValue(n)\\n runningBestVal = problem.getObjValue(runningBest)\\n if problem.isBetter(nObjVal, runningBestVal):\\n runningBest = n\\n if runningBest is currentState:\\n # no neighbour is better, check against the bestYet\\n runningBestVal = problem.getObjValue(runningBest)\\n bestYetVal = problem.getObjValue(bestYet)\\n if problem.isBetter(runningBestVal, bestYetVal):\\n bestYet = runningBest\\n else:\\n # jump to best neighbour\\n currentState = runningBest\\n\\n # for visualization later on\\n problem.hVals.append(problem.getObjValue(currentState))\\n \\n if not beQuiet:\\n print(\\\"Greedy step taken.\\\")\\n if userInteraction:\\n input(\\\"Press enter to continue \\\")\\n problem.visualize(currentState)\\n currentVal = problem.getObjValue(currentState)\\n bestYetVal = problem.getObjValue(bestYet)\\n if problem.isBetter(currentVal, bestYetVal):\\n bestYet = currentState\\n steps+=1\\n else:\\n # do a random restart\\n currentState = problem.getRandomState()\\n \\n # for visualization later on\\n problem.hVals.append(problem.getObjValue(currentState))\\n if not beQuiet:\\n if userInteraction:\\n input(\\\"Press enter to continue \\\")\\n print(\\\"Random restart done.\\\")\\n problem.visualize(currentState)\\n \\n currentVal = problem.getObjValue(currentState)\\n bestYetVal = problem.getObjValue(bestYet)\\n if problem.isBetter(currentVal, bestYetVal):\\n bestYet = currentState\\n \\n restarts+=1\\n steps+=1\\n # after running out of steps, return the best yet state\\n print(f\\\"\\\\n[INFO] Total number of random restarts done: {restarts}.\\\")\\n return steps, bestYet\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE ***\\\"\\n from game import Actions\\n\\n waiting_list = util.PriorityQueue()\\n COSTS = {}\\n start_state = problem.getStartState()\\n COSTS[start_state] = 0\\n waiting_list.push(start_state,0)\\n parents = {}\\n \\n while not waiting_list.isEmpty():\\n q_state = waiting_list.pop()\\n if problem.isGoalState(q_state):\\n target_state = q_state\\n break\\n for child in problem.getSuccessors(q_state):\\n n_cost = COSTS[q_state] + child[2]\\n \\n if child[0] not in COSTS or n_cost < COSTS[q_state]:\\n COSTS[child[0]] = n_cost\\n prior = n_cost + heuristic(child[0], problem)\\n waiting_list.push(child[0], prior)\\n parents[child[0]] = q_state\\n\\n sequence = []\\n prev_state = target_state\\n while target_state in parents.keys():\\n target_state = parents[target_state]\\n direction = Actions.vectorToDirection([prev_state[0] - target_state[0], prev_state[1] - target_state[1]])\\n prev_state = target_state\\n sequence.append(direction)\\n \\n return sequence[::-1]\",\n \"def fastest_path_estimation(sol):\\n\\n class Path:\\n def __init__(self, places, graph):\\n self.g = 0 # current cost\\n self.graph = graph\\n self.visited = [places[0]] # list of already visited attractions\\n self.not_visited = copy.deepcopy(places[1:]) # list of attractions not yet visited\\n\\n def __lt__(self, other):\\n return self.g < other.g\\n\\n def add(self, idx):\\n # add the cost\\n self.g += self.graph[self.visited[-1], idx]\\n # add the to the visited place and remove from the unvisited places\\n self.visited.append(idx)\\n self.not_visited.remove(idx)\\n\\n def add_to_heap_queue(path):\\n # custom function to add to heap queue sorted by the solution's cost\\n heappush(h_queue, path)\\n\\n if len(sol.not_visited) == 0:\\n return 0\\n elif len(sol.not_visited) == 1:\\n return sol.graph[sol.visited[-1], sol.not_visited[0]]\\n\\n c = sol.visited[-1]\\n pm = sol.not_visited[-1]\\n # the heap queue of solution sorted by their cost - change all to tuples with g for dijkstra\\n h_queue = []\\n\\n # the places to use for the graph\\n sub_search_places = [c]\\n sub_search_places.extend(sol.not_visited)\\n\\n # push the first \\\"node\\\" in the queue\\n add_to_heap_queue(Path(sub_search_places, sol.graph))\\n while True:\\n # take the next solution with the shortest cost\\n path = heappop(h_queue)\\n # if it contains destination, stop and return that solution\\n if pm in path.visited:\\n return path.g\\n # create a new solution for each neighbor of the current vertex and add it to heap queue\\n for place in path.not_visited:\\n new_path = copy.deepcopy(path)\\n new_path.add(place)\\n add_to_heap_queue(new_path)\",\n \"def solve(G):\\n\\n dominatingSet = nx.algorithms.approximation.dominating_set.min_weighted_dominating_set(G, weight=\\\"weight\\\")\\n\\n # Create the graph T and input the dominating set.\\n T = nx.Graph()\\n T.add_nodes_from(dominatingSet)\\n\\n # When the graph is fully dominated by one node, the cost is zero.\\n if len(dominatingSet) == 1:\\n return T\\n\\n # The variable defined below, apsp, stands for all pairs shortest paths from calling NetworkX built-in Dijkstra's algorithm.\\n apsp = dict(nx.algorithms.shortest_paths.weighted.all_pairs_dijkstra(G, weight = \\\"weight\\\"))\\n\\n # In each iteration of the following for loop, we connect node to node2.\\n node2 = None\\n for node in dominatingSet:\\n\\n connected_nodes = nx.dfs_preorder_nodes(T, source=node2)\\n\\n print(\\\"Connecting \\\", node, \\\"to\\\", node2)\\n print(node2, \\\"descendants: \\\", [n for n in connected_nodes])\\n\\n if node2 is not None and node2 not in list(connected_nodes):\\n\\n # We want to connect node to node2 in the cheapest way possible.\\n # Thus, we search from all nodes connected to node2.\\n # By default, we choose the shortest path from node to node2.\\n shortest_path = apsp[node2][1][node]\\n path_cost = apsp[node2][0][node]\\n\\n # Now, evaluate if there is a shorter, cheaper path from a different vertex.\\n for connected_node in list(nx.dfs_preorder_nodes(T, source=node2)):\\n print(\\\" Cheapest path from \\\" + str(connected_node) + \\\": \\\" + str(apsp[connected_node][0][node]))\\n if apsp[connected_node][0][node] < path_cost:\\n shortest_path = apsp[connected_node][1][node]\\n path_cost = apsp[connected_node][0][node]\\n print(\\\"Updating best path to \\\" + str(shortest_path) + \\\", cost \\\" + str(path_cost))\\n\\n print(\\\"Found path via \\\" + str(shortest_path) + \\\" of cost \\\" + str(path_cost))\\n\\n # Add all necessary vertices.\\n for vertex in shortest_path:\\n if vertex not in dominatingSet:\\n T.add_node(vertex)\\n\\n # Add all necessary edges.\\n for i in range(len(shortest_path) - 1):\\n origin = shortest_path[i]\\n terminus = shortest_path[i+1]\\n T.add_edge(origin, terminus, weight=G.get_edge_data(origin, terminus)['weight'])\\n #T[origin][terminus]['weight'] = G.get_edge_data(origin, terminus)['weight']\\n\\n node2 = node\\n print()\\n\\n current_average = average_pairwise_distance(T)\\n last_average = 4000\\n print(current_average)\\n\\n # Until adding more edges doesn't improve the average pairwise cost\\n while current_average < last_average:\\n last_average = current_average\\n # For every node in T\\n for node in nx.dfs_preorder_nodes(T, source=list(T.nodes)[0]):\\n neighbors = nx.algorithms.traversal.breadth_first_search.bfs_tree(G, node, reverse=False, depth_limit=1)\\n # Get one of its neighbors NOT in T\\n for node2 in neighbors:\\n # and add the edge between that vertex and its neighbor\\n # if it decreases the average pairwise cost.\\n if node2 not in T and G.get_edge_data(node, node2)\\\\\\n and G[node][node2]['weight'] < current_average:\\n T.add_node(node2)\\n T.add_edge(node, node2, weight=G.get_edge_data(node, node2)['weight'])\\n new_average = average_pairwise_distance(T)\\n if new_average > current_average:\\n T.remove_node(node2)\\n #T.remove_edge(node, node2)\\n else:\\n current_average = new_average\\n print(\\\"Adding an edge between\\\", node, \\\"and\\\", node2, \\\"yields average\\\", new_average)\\n\\n\\n\\n print(\\\"Dominating vertices:\\\", [node for node in T])\\n\\n return T\",\n \"def get_solution(self):\\n start_time = time.clock()\\n frontier = [Node(self, None, 0, None)]\\n explored = []\\n visited = 0\\n\\n while True:\\n visited += 1\\n # pop the lowest value from the frontier (sorted using bisect, so pop(0) is the lowest)\\n node = frontier.pop(0)\\n\\n # if the current node is at the goal state, we're done! \\n if node.board.h() == 0:\\n # recursively compile a list of all the moves\\n moves = []\\n while node.parent:\\n moves.append(node.action)\\n node = node.parent\\n moves.reverse()\\n\\n print(\\\"Time:\\\", time.clock() - start_time)\\n return calcal(moves, self.original)\\n # print(\\\"Solution found!\\\")\\n # print(\\\"Moves:\\\", len(moves))\\n # print(\\\"Nodes visited:\\\", visited)\\n # print(\\\"All moves:\\\", \\\", \\\".join(str(move) for move in moves))\\n # break\\n else:\\n # we're not done yet:\\n # expand the node, and add the new nodes to the frontier, as long\\n # as they're not in the frontier or explored list already\\n for new_node in node.expand():\\n if new_node not in frontier and new_node not in explored:\\n # use bisect to insert the node at the proper place in the frontier\\n bisect.insort(frontier, new_node)\\n \\n explored.append(node)\",\n \"def get_routing_solution(self):\\n G = self.base_digraph\\n s1 = self.sources[0]\\n s2 = self.sources[1]\\n t1 = self.destinations[0]\\n t2 = self.destinations[1]\\n\\n try:\\n m = Model('routing')\\n m.setParam('OutputFlag', False)\\n\\n # variables,\\n # We have one variable per edge per session\\n # e is the dict of dict for the variables\\n e = {}\\n r = {}\\n for i in [1,2]:\\n e[i] = {}\\n r[i] = m.addVar()\\n for u,v in G.edges():\\n e[i][u,v] = m.addVar(lb=0)\\n\\n m.update()\\n\\n obj = quicksum(r.values())\\n m.setObjective(obj, GRB.MAXIMIZE)\\n\\n # constraints\\n # 1. conservations of flow at all intermediate nodes\\n # 2. capacity constraints for each edge\\n\\n for u,v in G.edges():\\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\\n\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\\n\\n for n in G.nodes():\\n if n not in [s1, s2, t1, t2]:\\n for i in [1, 2]:\\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\\n m.addConstr(inflow == outflow)\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n for u, v in G.edges():\\n G[u][v]['Routing'] = {}\\n G[u][v]['Routing'][1] = e[1][u,v].x\\n G[u][v]['Routing'][2] = e[2][u,v].x\\n return (m.objVal, r[1].x, r[2].x)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong, no optimal solution obtained\\\"\\n return None, None, None\\n\\n except GurobiError:\\n Print ('Error Report from Gurobi')\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE IF YOU WANT TO PRACTICE ***\\\"\\n\\n priorityFunc = lambda x: x[2] + 1*heuristic(x[0], problem)\\n\\n # initialize a priority queue\\n open = util.PriorityQueue()\\n closed = []\\n\\n # Retrieve the init state\\n init = (problem.getStartState(), ['Stop'], 0)\\n open.push(init, priorityFunc(init))\\n while not open.isEmpty():\\n currNode = open.pop()\\n currState = currNode[0]\\n currPath = currNode[1]\\n currPathCost = currNode[2]\\n if problem.isGoalState(currState):\\n return currPath[1:]\\n else:\\n closed.append(currState)\\n successors = problem.getSuccessors(currState)\\n\\n if len(successors) > 0:\\n for each in successors:\\n newPos = each[0]\\n newPathCost = currPathCost + each[2]\\n\\n if newPos not in closed:\\n temp = (each[0], currPath + [each[1]], newPathCost)\\n open.update(temp, priorityFunc(temp))\\n\\n return False\",\n \"def change_way(coins, opponentLocation, player_location):\\n global best_weight, best_path\\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(5, coins, player_location, dists_matrix)\\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 best_weight = float(\\\"inf\\\")\\n best_path = []\\n api.debug(coins_to_search)\\n exhaustive(coins_to_search, player_location, [], 0, dist_matrix)\\n meta_route = [player_location] + best_path\\n api.debug(meta_route)\\n route = u.location_list_to_route(meta_route, route_matrix)\\n \\n return coins_to_search, meta_route, route, dist_matrix[player_location][meta_route[1]]\",\n \"def local_optimum(self, tour: Tour):\\n better = tour\\n cnt = 0\\n while better is not None:\\n # if cnt % 20 == 0:\\n print(\\\"---------------------------------------------\\\\n The \\\", cnt, \\\"time.\\\")\\n print(\\\"Improved tour:\\\", list(better.iter_vertices()))\\n print(\\\"Improved cost:\\\", self.tour_cost(better))\\n cnt += 1\\n tour = better\\n better = self.improve(tour)\\n return tour\",\n \"def a_star(my_map, start_locs, goal_locs, h_values, agent, constraints):\\n\\n ##############################\\n # Task 1.1: Extend the A* search to search in the space-time domain\\n # rather than space domain, only.\\n # Build constraint table if there are constraints\\n\\n constraint_table = build_constraint_table(constraints, agent)\\n\\n open_list = []\\n closed_list = dict()\\n nodes_opened = 0\\n max_opened = 500\\n start_loc = start_locs[0]\\n goal_loc = goal_locs[0]\\n if len(start_locs) > 1: # If there is more than 1 start location then this is a multi-cell agent\\n multi = True\\n else:\\n multi = False\\n\\n # determine when the last constraint is on the goal node (or any of the goal node cells in the case of multi-cell)\\n earliest_goal_timestep = 0\\n if len(constraint_table) != 0:\\n for time in [item for item in sorted(list(constraint_table.keys()), reverse=True)]:\\n flat_list = [item for sublist in constraint_table[time] for item in sublist]\\n if(goal_locs[0] in flat_list):\\n earliest_goal_timestep = time\\n break\\n elif(multi): # if multi cell check if any of the agents goal cells are constrained \\n if(goal_locs[1] in flat_list): \\n earliest_goal_timestep = time\\n break\\n\\n h_value = h_values[start_loc]\\n goal_orientation = orientation(goal_locs)\\n\\n root = {'loc': start_loc,'orientation': orientation(start_locs), 'g_val': 0, 'h_val': h_value, 'time': 0, 'parent': None}\\n push_node(open_list, root)\\n closed_list[(root['loc'], root['time'], root['orientation'])] = root\\n\\n while len(open_list ) > 0 and nodes_opened < max_opened:\\n curr = pop_node(open_list)\\n nodes_opened = nodes_opened + 1\\n \\n if curr['loc'] == goal_loc and curr['orientation'] == goal_orientation and curr['time'] >= earliest_goal_timestep:\\n return get_path(curr)\\n ############################\\n child_orient = curr['orientation']\\n for dir in range(7):\\n if dir < 5:\\n child_loc = move(curr['loc'], dir)\\n elif not multi: \\n continue\\n\\n if dir == 5:\\n # clockwise rotation \\n child_orient = curr['orientation'] - 1\\n if child_orient < 1:\\n child_orient = 4\\n if dir == 6:\\n # counter-clockwise rotation \\n child_orient = curr['orientation'] + 1\\n if child_orient > 4:\\n child_orient = 1\\n \\n if test_map(my_map, child_loc[0], child_loc[1], child_orient, dir):\\n continue\\n \\n # check if the head location is constrained \\n if is_constrained(curr['loc'], child_loc, child_orient, dir, curr['time'] + 1, constraint_table):\\n continue\\n\\n # if this is a multi cell agent check if the tail is constrained \\n if multi:\\n # check the next tail location \\n row_t, col_t, _, _ = find_tail_positions(curr['loc'][0], curr['loc'][1], curr['orientation'], dir)\\n next_row_t, next_col_t, next_row_t_inter, next_col_t_inter = find_tail_positions(child_loc[0], child_loc[1], child_orient, dir)\\n\\n if is_constrained((row_t,col_t), (next_row_t, next_col_t), child_orient, dir, curr['time'] + 1, constraint_table):\\n continue\\n\\n # if the agent is rotating check if the intermediate location is constrained\\n if dir == 5 or dir == 6: \\n if is_constrained((row_t,col_t), (next_row_t_inter, next_col_t_inter), child_orient, dir, curr['time'] + 1, constraint_table):\\n continue\\n\\n child = {'loc': child_loc,\\n 'orientation': child_orient,\\n 'g_val': curr['g_val'] + 1,\\n 'h_val': h_values[child_loc] + orient_cost(child_orient, goal_orientation),\\n 'time': curr['time'] + 1,\\n 'parent': curr}\\n\\n if (child['loc'], child['time'], child['orientation']) in closed_list:\\n existing_node = closed_list[(child['loc'], child['time'], child['orientation'])]\\n \\n if compare_nodes(child, existing_node):\\n closed_list[(child['loc'], child['time'], child['orientation'])] = child\\n push_node(open_list, child)\\n else:\\n closed_list[(child['loc'], child['time'], child['orientation'])] = child\\n push_node(open_list, child)\\n \\n return None # Failed to find solutions\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n path_to_point = {}\\n cost_to_point = {}\\n\\n # Get the start node\\n start_node = problem.getStartState()\\n fringe_node = [start_node]\\n path_to_point[start_node] = []\\n cost_to_point[start_node] = problem.getCostOfActions(path_to_point[start_node])\\n\\n goal_found = False\\n\\n while(not goal_found):\\n #for i in range(100): \\n nodes_to_expand = set()\\n # get max value node in the fringe node\\n min_val = float(\\\"inf\\\")\\n for one_node in fringe_node:\\n # Compute the cost to reach a node\\n if cost_to_point[one_node] < min_val:\\n min_val = cost_to_point[one_node]\\n \\n for one_node in fringe_node:\\n # Compute the cost to reach a node\\n if cost_to_point[one_node] == min_val:\\n nodes_to_expand.add(one_node)\\n fringe_node.remove(one_node)\\n\\n # Expand the fringe node \\n for one_node in nodes_to_expand:\\n path_to_parent = path_to_point[one_node]\\n for nxt_node in problem.getSuccessors(one_node):\\n pos = nxt_node[0]\\n mv = nxt_node[1]\\n # check if point already present in path to point\\n prev_cost = float(\\\"inf\\\")\\n if pos in cost_to_point:\\n prev_cost = cost_to_point[pos]\\n new_path = path_to_parent + [mv]\\n if prev_cost > problem.getCostOfActions(new_path):\\n path_to_point[pos] = new_path\\n cost_to_point[pos] = problem.getCostOfActions(new_path)\\n fringe_node.append(pos)\\n\\n # Check if destination is reached in the fringe node\\n for one_node in fringe_node:\\n if problem.isGoalState(one_node):\\n final_node = one_node\\n goal_found = True\\n break\\n \\n #print(len(fringe_node))\\n print(final_node)\\n print(path_to_point[final_node])\\n return path_to_point[final_node] \\n\\n util.raiseNotDefined()\",\n \"def solve(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix, params=[]):\\n\\n\\n\\n\\n path = [starting_car_location]\\n dict = {}\\n index = 0\\n for i in range(len(list_of_locations)):\\n if list_of_locations[i] == starting_car_location:\\n index = i\\n\\n path = [index]\\n\\n G, m = adjacency_matrix_to_graph(adjacency_matrix)\\n\\n home_indexes = []\\n\\n for home in list_of_homes:\\n for i in range(len(list_of_locations)):\\n if list_of_locations[i] == home:\\n home_indexes.append(i)\\n break\\n\\n new_adjacency = [[\\\"x\\\" for i in range(len(list_of_locations))] for j in range(len(list_of_locations))]\\n\\n # for sake of figuring out where to walk\\n for home in home_indexes:\\n di_path = nx.dijkstra_path(G, index, home)\\n for i in range(len(di_path) - 1):\\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n\\n\\n for home1 in home_indexes:\\n for home2 in home_indexes:\\n if not home1 == home2:\\n di_path = nx.dijkstra_path(G, home1, home2)\\n for i in range(len(di_path) - 1):\\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n\\n\\n\\n\\n G2, m = adjacency_matrix_to_graph(new_adjacency)\\n\\n all_driving_path = list(nx.dfs_edges(G2))\\n\\n\\n\\n\\n walking_to = []\\n walking_from = {}\\n\\n for i in range(len(new_adjacency)):\\n if i in home_indexes:\\n count = 0\\n edge_to = 0\\n for j in range(len(new_adjacency)):\\n if new_adjacency[i][j] != \\\"x\\\":\\n count += 1\\n edge_to = j\\n\\n #must ensure that this is not a home that we are already dropping someone off at, otherwise it will cut off a line of two homes\\n if count == 1 and i != index and i not in walking_from.keys():\\n new_adjacency[i][edge_to] = \\\"x\\\"\\n new_adjacency[edge_to][i] = \\\"x\\\"\\n walking_to.append(i)\\n if edge_to in walking_from:\\n walking_from[edge_to] = walking_from[edge_to] + [i]\\n else:\\n walking_from[edge_to] = [i]\\n\\n #\\n # for i in range(len(all_driving_path) - 1):\\n # #if first vertex in edge is the same, we should walk\\n # if all_driving_path[i][0] == all_driving_path[i + 1][0]:\\n # print(all_driving_path[i][0])\\n # print(all_driving_path[i][1])\\n # #get rid of only edge connected to this home\\n # new_adjacency[all_driving_path[i][0]][all_driving_path[i][1]] = \\\"x\\\"\\n # new_adjacency[all_driving_path[i][1]][all_driving_path[i][0]] = \\\"x\\\"\\n # walking_to.append(all_driving_path[i][1])\\n # if all_driving_path[i][0] in walking_from:\\n # walking_from[all_driving_path[i][0]] = walking_from[all_driving_path[i][0]] + [all_driving_path[i][1]]\\n # else:\\n # walking_from[all_driving_path[i][0]] = [all_driving_path[i][1]]\\n\\n\\n\\n dropoff_locations = list(walking_from.keys())\\n for loc in dropoff_locations:\\n if loc in home_indexes:\\n dropoff_locations.remove(loc)\\n\\n\\n for loc in dropoff_locations:\\n di_path = nx.dijkstra_path(G, loc, home)\\n for i in range(len(di_path) - 1):\\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n\\n for loc in dropoff_locations:\\n for home in home_indexes:\\n di_path = nx.dijkstra_path(G, loc, home)\\n for i in range(len(di_path) - 1):\\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n\\n\\n G2, m = adjacency_matrix_to_graph(new_adjacency)\\n # G = G2\\n # pos=nx.spring_layout(G2)\\n # nx.draw_networkx_nodes(G2,pos)\\n # nx.draw_networkx_labels(G2, pos)\\n # nx.draw_networkx_edges(G2,pos,width=1.0,alpha=0.5)\\n #\\n # plt.draw()\\n # plt.show()\\n\\n # condensed shortest paths to edges - use G3 for real\\n\\n new_adjacency2 = [[\\\"x\\\" for i in range(len(list_of_locations))] for j in range(len(list_of_locations))]\\n\\n for home in home_indexes:\\n if home not in walking_to:\\n di_path = nx.dijkstra_path(G2, index, home)\\n start = di_path[0]\\n end = di_path[len(di_path) - 1]\\n new_adjacency2[start][end] = 0\\n new_adjacency2[end][start] = 0\\n for i in range(len(di_path) - 1):\\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\\n\\n\\n for home1 in home_indexes:\\n for home2 in home_indexes:\\n if not home1 == home2 and home1 not in walking_to and home2 not in walking_to:\\n di_path = nx.dijkstra_path(G2, home1, home2)\\n start = di_path[0]\\n end = di_path[len(di_path) - 1]\\n new_adjacency2[start][end] = 0\\n new_adjacency2[end][start] = 0\\n for i in range(len(di_path) - 1):\\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\\n\\n for loc in dropoff_locations:\\n di_path = nx.dijkstra_path(G2, index, loc)\\n start = di_path[0]\\n end = di_path[len(di_path) - 1]\\n new_adjacency2[start][end] = 0\\n new_adjacency2[end][start] = 0\\n for i in range(len(di_path) - 1):\\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\\n\\n for loc in dropoff_locations:\\n for home in home_indexes:\\n di_path = nx.dijkstra_path(G2, loc, home)\\n start = di_path[0]\\n end = di_path[len(di_path) - 1]\\n new_adjacency2[start][end] = 0\\n new_adjacency2[end][start] = 0\\n for i in range(len(di_path) - 1):\\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\\n\\n\\n\\n\\n final_G, m = adjacency_matrix_to_graph(new_adjacency2)\\n drive_path = list(nx.dfs_edges(final_G, source=index))\\n drive_path.append(index)\\n\\n mst = nx.minimum_spanning_tree(final_G)\\n\\n\\n\\n new_mst = nx.MultiGraph(mst)\\n for edge in mst.edges():\\n new_mst.add_edge(edge[0], edge[1])\\n\\n\\n if new_mst.degree[index] != 0:\\n to_remove = []\\n for node in new_mst:\\n if (new_mst.degree[node] == 0):\\n to_remove.append(node)\\n new_mst.remove_nodes_from(to_remove)\\n\\n eulerian = list(nx.eulerian_circuit(new_mst, index))\\n\\n path = []\\n for edge in eulerian:\\n path.append(edge[0])\\n\\n path.append(eulerian[len(eulerian) - 1][1])\\n\\n already_seen = []\\n to_remove = []\\n for i in range(len(path) - 1):\\n if path[i] in already_seen:\\n to_remove.append(i)\\n else:\\n already_seen.append(path[i])\\n\\n new_path = []\\n for i in range(len(path) - 1):\\n if i not in to_remove:\\n new_path.append(path[i])\\n path = new_path\\n print(eulerian)\\n else:\\n path = [index]\\n print(path)\\n\\n\\n\\n\\n\\n\\n\\n # print(path)\\n final_path = []\\n for node in path:\\n if node == index:\\n final_path.append(node)\\n # print(\\\"Index: \\\", node)\\n elif node in home_indexes and node not in walking_to:\\n final_path.append(node)\\n # print(\\\"Home but not walking: \\\", node)\\n elif node in dropoff_locations:\\n final_path.append(node)\\n # print(\\\"Dropoff loc: \\\", node)\\n final_path.append(index)\\n #print(walking_from)\\n # print(final_path)\\n # nx.draw(mst)\\n # plt.draw()\\n # plt.show()\\n for node in final_path:\\n if node in walking_from and node in home_indexes:\\n dict[node] = [node] + walking_from[node]\\n elif node in home_indexes:\\n dict[node] = [node]\\n elif node in walking_from:\\n dict[node] = walking_from[node]\\n\\n very_final_path = []\\n for i in range(len(final_path) - 1):\\n condensed_path = nx.dijkstra_path(G2, final_path[i], final_path[i+1])\\n for j in range(len(condensed_path) - 1):\\n if condensed_path[j] != condensed_path[j + 1]:\\n very_final_path.append(condensed_path[j])\\n\\n if len(very_final_path) >= 1 and [len(very_final_path) - 1] != index:\\n very_final_path.append(index)\\n\\n if len(very_final_path) == 0:\\n very_final_path = [index]\\n\\n print(very_final_path)\\n print(dict)\\n\\n\\n path2 = list(nx.dfs_preorder_nodes(mst, index))\\n\\n final_path2 = []\\n for node in path2:\\n if node == index:\\n final_path2.append(node)\\n # print(\\\"Index: \\\", node)\\n elif node in home_indexes and node not in walking_to:\\n final_path2.append(node)\\n # print(\\\"Home but not walking: \\\", node)\\n elif node in dropoff_locations:\\n final_path2.append(node)\\n # print(\\\"Dropoff loc: \\\", node)\\n final_path2.append(index)\\n\\n\\n for node in final_path2:\\n if node in walking_from and node in home_indexes:\\n dict[node] = [node] + walking_from[node]\\n elif node in home_indexes:\\n dict[node] = [node]\\n elif node in walking_from:\\n dict[node] = walking_from[node]\\n\\n very_final_path2 = []\\n for i in range(len(final_path2) - 1):\\n condensed_path = nx.dijkstra_path(G2, final_path2[i], final_path2[i+1])\\n for j in range(len(condensed_path) - 1):\\n if condensed_path[j] != condensed_path[j + 1]:\\n very_final_path2.append(condensed_path[j])\\n\\n if len(very_final_path2) >= 1 and [len(very_final_path2) - 1] != index:\\n very_final_path2.append(index)\\n\\n if len(very_final_path2) == 0:\\n very_final_path2 = [index]\\n\\n opt1 = cost_of_solution(G, very_final_path, dict)\\n opt2 = cost_of_solution(G, very_final_path2, dict)\\n\\n ultra_final_path = []\\n if (opt1 <= opt2):\\n ultra_final_path = very_final_path\\n else:\\n ultra_final_path = very_final_path2\\n\\n return ultra_final_path, dict\\n\\n pass\",\n \"def cornersHeuristic(state, problem):\\n corners = problem.corners # These are the corner coordinates\\n walls = problem.walls # These are the walls of the maze, as a Grid (game.py)\\n distance = []\\n for i in range(len(corners)):\\n distance.append(fabs((corners[i][0] - state[0][0]) + (corners[i][1] - state[0][1])))\\n \\\"*** YOUR CODE HERE ***\\\"\\n return min(distance) # Default to trivial solution\",\n \"def TSP_ILP(G):\\n V1 = range(len(G))\\n n, V = len(G), set(V1)\\n model = Model() # binary variables indicating if arc (i,j) is used\\n # on the route or not\\n x = [[model.add_var(var_type=BINARY) for j in V] for i in V]\\n # continuous variable to prevent subtours: each city will have a\\n # different sequential id in the planned route except the 1st one\\n y = [model.add_var() for i in V]\\n # objective function: minimize the distance\\n model.objective = minimize(xsum(G[i][j]*x[i][j] for i in V for j in V))\\n\\n # constraint : leave each city only once\\n for i in V:\\n model += xsum(x[i][j] for j in V - {i}) == 1\\n # constraint : enter each city only once\\n for i in V:\\n model += xsum(x[j][i] for j in V - {i}) == 1 # subtour elimination\\n for (i, j) in product(V - {0}, V - {0}):\\n if i != j:\\n model += y[i] - (n+1)*x[i][j] >= y[j]-n # optimizing\\n\\n model.verbose = 0\\n model.optimize() # checking if a solution was found\\n\\n if model.num_solutions:\\n nc = 0 # cycle starts from vertex 0\\n cycle = [nc]\\n while True:\\n nc = [i for i in V if x[nc][i].x >= 0.99][0]\\n cycle.append(nc)\\n if nc == 0:\\n break\\n\\n return (model.objective_value, cycle)\",\n \"def solve(self, debug: bool = False) -> np.ndarray:\\n coords = self.start\\n priority_queue = [(0, 0, coords, [coords])] # Loss must go first!\\n heapq.heapify(priority_queue)\\n\\n while priority_queue:\\n _, distance_, coords, path = heapq.heappop(priority_queue)\\n\\n neighbors = self.neighbors(coords)\\n # all_losses = [distance_ + self.heuristic(n) for n in neighbors]\\n all_losses = [self.heuristic(n) for n in neighbors]\\n\\n not_visited = [n for n in neighbors if n in set(neighbors) - set(path)] # Preserve order\\n losses = [all_losses[i] for i in range(len(all_losses))\\n if neighbors[i] in not_visited]\\n\\n for loss, neighbor in [(loss, n) for loss, n in sorted(zip(losses, not_visited))]:\\n if neighbor == self.finish:\\n coords = neighbor\\n self.path = np.array(path + [neighbor])\\n priority_queue = []\\n break\\n else:\\n # heapq.heappush(priority_queue, (distance_ + 1 + loss, distance_ + 1, neighbor, path + [neighbor]))\\n heapq.heappush(priority_queue, (loss, distance_ + 1, neighbor, path + [neighbor]))\\n\\n if debug:\\n print(coords)\\n # print(neighbors)\\n # print(losses)\\n print([(loss, n) for loss, n in sorted(zip(losses, not_visited))])\\n\\n if coords != self.finish:\\n if debug:\\n print(coords, self.finish)\\n\\n raise NoSolutionsError('No solution has been found.')\\n else:\\n print('Solution has been found!')\\n\\n return self.path\",\n \"def find_solution(self, time_limit=5, objective='min_best_case', sic=True, min_time_policy=True):\\n self.open_list = OpenListHeap()\\n self.open_dict = {} # A dictionary mapping node tuple to the actual node. Used for faster access.\\n self.closed_set = set()\\n start_time = time.time()\\n start_node = ODState(self.startPositions, self.goalPositions, None, None, (0, 0), self.grid_map)\\n self.__add_node_to_open(start_node, objective)\\n while len(self.open_list.internal_heap) > 0:\\n if time.time() - start_time > time_limit:\\n print(f\\\"ODA timed out. Nodes expanded: {len(self.closed_set)}\\\")\\n print(f'Number of nodes in open: {len(self.open_dict)}')\\n raise OutOfTimeError('Ran out of time :-(')\\n if len(self.open_dict) + len(self.closed_set) > self.max_nodes:\\n raise OutOfTimeError('Expanded too many nodes - Exit prior to memory error :-(')\\n best_node = self.open_list.pop() # removes from open_list\\n self.__remove_node_from_open(best_node)\\n\\n if self.is_goal_node(best_node):\\n return best_node.calc_solution(self.startPositions, sic) + (len(self.closed_set),)\\n\\n successors = best_node.expand(self.grid_map, sic, min_time_policy)\\n\\n for neighbor in successors:\\n neighbor_tuple = neighbor.create_tuple()\\n if neighbor_tuple in self.closed_set: # Has been expanded.\\n continue\\n if neighbor_tuple not in self.open_dict: # Reached for the first time.\\n self.__add_node_to_open(neighbor, objective)\\n else: # We might need to update the node.\\n old_node = self.open_dict[neighbor_tuple] # Node wac reached before\\n if self.is_new_node_better(neighbor, old_node, objective):\\n self.__update_node(neighbor, old_node)\\n\\n return None, math.inf # no solution\",\n \"def astar_multi(maze):\\n heuristic_lookup = {} \\n objs = maze.getObjectives()\\n corner_list = maze.getObjectives()\\n start = maze.getStart()\\n path = []\\n dim = maze.getDimensions()\\n visited = {}\\n lookup_table = {}\\n p_queue = []\\n edgeset = []\\n mintree = {}\\n start_heuristic = 0 + multi_dot_heuristic_query(maze, start, objs, edgeset, mintree) \\n heuristic_lookup[(start, tuple(objs))] = start_heuristic\\n start_state = state(start, corner_list)\\n lookup_table[state(start, corner_list)] = (start_heuristic, 0, state((-2, -2)))\\n p_queue.append((start_heuristic, state(start, corner_list)))\\n while p_queue:\\n pair = p_queue.pop(0)\\n visited[pair[1]] = lookup_table.get(pair[1])[2]\\n if not pair[1].getlist():\\n current_state = pair[1]\\n while current_state != start_state:\\n path.append(current_state.getpos())\\n current_state = visited.get(current_state)\\n path.append(start)\\n path.reverse()\\n return path\\n else: \\n list_of_neighbors = maze.getNeighbors(pair[1].getpos()[0], pair[1].getpos()[1])\\n for coordinates in list_of_neighbors:\\n current_state = state(coordinates)\\n if coordinates in pair[1].getlist():\\n new_list = copy.copy(pair[1].getlist())\\n new_list.remove(coordinates)\\n current_state = state(coordinates, new_list)\\n else:\\n current_state = state(coordinates, pair[1].getlist()) \\n if current_state in visited:\\n continue\\n if current_state in lookup_table:\\n if (lookup_table.get(current_state)[0], current_state) in p_queue:\\n cost = lookup_table.get(pair[1])[1] + 1\\n queried_heuristic = 0\\n if (current_state.getpos(), tuple(current_state.getlist())) in heuristic_lookup:\\n queried_heuristic = heuristic_lookup.get((current_state.getpos(), tuple(current_state.getlist())))\\n else:\\n queried_heuristic = multi_dot_heuristic_query(maze, current_state.getpos(), current_state.getlist(), edgeset, mintree)\\n heuristic_lookup[(current_state.getpos(), tuple(current_state.getlist()))] = queried_heuristic\\n heuristic = queried_heuristic + cost\\n old_heuristic = lookup_table.get(current_state)[0]\\n if heuristic < lookup_table.get(current_state)[0]:\\n lookup_table[current_state] = (heuristic, cost, pair[1])\\n p_queue.remove((old_heuristic, current_state))\\n bisect.insort(p_queue, (heuristic, current_state))\\n else:\\n cost = lookup_table.get(pair[1])[1] + 1\\n queried_heuristic = 0\\n if (current_state.getpos(), tuple(current_state.getlist())) in heuristic_lookup:\\n queried_heuristic = heuristic_lookup.get((current_state.getpos(), tuple(current_state.getlist())))\\n else:\\n queried_heuristic = multi_dot_heuristic_query(maze, current_state.getpos(), current_state.getlist(), edgeset, mintree) \\n heuristic_lookup[(current_state.getpos(), tuple(current_state.getlist()))] = queried_heuristic\\n heuristic = queried_heuristic + cost\\n lookup_table[current_state] = (heuristic, cost, pair[1])\\n bisect.insort(p_queue, (heuristic, current_state))\\n return []\",\n \"def waStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE FOR TASK 2 ***\\\"\\n\\n priorityFunc = lambda x: x[2] + 2*heuristic(x[0], problem)\\n\\n # initialize a priority queue\\n open = util.PriorityQueue()\\n closed = []\\n consistencyCheck = []\\n\\n # Retrieve the init state\\n init = (problem.getStartState(), ['Stop'], 0)\\n open.push(init, priorityFunc(init))\\n while not open.isEmpty():\\n currNode = open.pop()\\n currState = currNode[0]\\n currPath = currNode[1]\\n currPathCost = currNode[2]\\n\\n h0 = heuristic(currState, problem)\\n\\n if problem.isGoalState(currState):\\n print(\\\"consistent? :\\\", consistencyCheck.count(True) == len(consistencyCheck))\\n return currPath[1:]\\n else:\\n closed.append(currState)\\n successors = problem.getSuccessors(currState)\\n\\n if len(successors) > 0:\\n for each in successors:\\n newState = each[0]\\n newPathCost = currPathCost + each[2]\\n h1 = heuristic(newState, problem)\\n consistencyCheck.append(h0-h1 <= 1)\\n if newState not in closed:\\n temp = (each[0], currPath + [each[1]], newPathCost)\\n open.update(temp, priorityFunc(temp))\\n\\n return False\",\n \"def find_path_best_first(world_nparray, heuristic_type=\\\"\\\"):\\n world_ndarray = np.copy(world_nparray)\\n start = tuple(np.argwhere(world_ndarray == -2)[0])\\n goal = tuple(np.argwhere(world_ndarray == -3)[0])\\n\\n world_ndarray[world_ndarray == -2] = 0\\n world_ndarray[world_ndarray == -3] = 0\\n\\n world_tuple = tuple(map(tuple, world_ndarray))\\n\\n pr_queue = [] # Use heapqueue as priority queue\\n heappush(pr_queue, (get_h(start, goal, heuristic_type), 0, \\\"\\\", start))\\n visited = set() # Each element has to be unique in a set\\n graph = get_neighbors(world_tuple)\\n route_str = \\\"\\\"\\n\\n while pr_queue:\\n _, cost, path, current = heappop(pr_queue)\\n if current == goal:\\n route_str = path\\n break\\n if current in visited:\\n continue\\n visited.add(current)\\n for direction, neighbour in graph[current].iteritems():\\n heappush(pr_queue, (get_h(neighbour, goal, heuristic_type), cost + 1, path + direction, neighbour))\\n world_ndarray[neighbour] = cost + 1\\n\\n # print \\\"Expanded nodes(Best First +\\\", heuristic_type, \\\"): \\\", len(visited), \\\"Path length: \\\", len(route_str)\\n # Convert string directions to 2D(x,y) coordinates\\n route_coord = [start]\\n for p in route_str:\\n route_coord.append(graph[route_coord[-1]][p])\\n\\n world_ndarray[start] = -2 # Mark the start and end coordinates again\\n world_ndarray[goal] = -3\\n\\n return route_coord, world_ndarray, len(visited), len(route_str)\",\n \"def solve_model(self,max_wait_time = 0,max_per_veh = 99999, save_output=True):\\n self.manager = pywrapcp.RoutingIndexManager(len(self.data['time_matrix']),\\n self.data['num_vehicles'], self.data['depot'])\\n routing = pywrapcp.RoutingModel(self.manager)\\n\\n transit_callback_index = routing.RegisterTransitCallback(self.time_callback)\\n routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)\\n time = 'Time'\\n routing.AddDimension(\\n transit_callback_index,\\n max_wait_time, # allow waiting time\\n max_per_veh, # maximum time per vehicle\\n False, # Don't force start cumul to zero.\\n time)\\n time_dimension = routing.GetDimensionOrDie(time)\\n # Add time window constraints for each location except depot.\\n for location_idx, time_window in enumerate(self.data['time_windows']):\\n if location_idx == 0:\\n continue\\n index = self.manager.NodeToIndex(location_idx)\\n time_dimension.CumulVar(index).SetRange(time_window[0], time_window[1]-self.VisitTime)\\n # Add time window constraints for each vehicle start node.\\n for vehicle_id in range(self.data['num_vehicles']):\\n index = routing.Start(vehicle_id)\\n time_dimension.CumulVar(index).SetRange(self.data['time_windows'][self.data['depot']][0],\\n self.data['time_windows'][self.data['depot']][1])\\n for i in range(self.data['num_vehicles']):\\n routing.AddVariableMinimizedByFinalizer(\\n time_dimension.CumulVar(routing.Start(i)))\\n routing.AddVariableMinimizedByFinalizer(\\n time_dimension.CumulVar(routing.End(i)))\\n '''Routing Settings:https://developers.google.com/optimization/routing/routing_options\\n '''\\n search_parameters = pywrapcp.DefaultRoutingSearchParameters()\\n search_parameters.first_solution_strategy = (\\n routing_enums_pb2.FirstSolutionStrategy.PATH_MOST_CONSTRAINED_ARC)\\n search_parameters.time_limit.seconds = 3600\\n #search_parameters.log_search = True\\n search_parameters.local_search_metaheuristic = (\\n routing_enums_pb2.LocalSearchMetaheuristic.AUTOMATIC)\\n sol_status={0:'ROUTING_NOT_SOLVED: Problem not solved yet.',\\n 1:'ROUTING_SUCCESS: Problem solved successfully.',\\n 2:'ROUTING_FAIL: No solution found to the problem.',\\n 3:'ROUTING_FAIL_TIMEOUT: Time limit reached before finding a solution.',\\n 4:'ROUTING_INVALID: Model, model parameters, or flags are not valid.'}\\n print('Start Solving the problem....')\\n _start_ = systime.time()\\n assignment = routing.SolveWithParameters(search_parameters)\\n print(\\\"Solver status: \\\", sol_status[routing.status()])\\n soltime = systime.time()-_start_\\n print('Solving takes: '+ str(round(soltime,2))+' Secs')\\n if assignment:\\n self.print_save_solution(routing, assignment,save_res=save_output)\\n else:\\n print('Solving Failed')\",\n \"def tryEverything(g, verbose, graphname):\\r\\n prio = ['rku', 'random', 'BIL', 'rkd', 'cluHPS', 'rkusd', 'rkuad']\\r\\n placement = ['eft', 'BIM*', 'OLB', 'MET', 'DL', 'GDL']\\r\\n costFunction = ['mean', 'median', 'maxmax', 'minmax', 'minmin', 'maxmin']\\r\\n desc = ['DLS/DC', None, 'DCP']\\r\\n useOfBIM = [False, True]\\r\\n insertion = [False, True]\\r\\n BSA = [False, True]\\r\\n res: Dict[str, List[float]] = {}\\r\\n cnt = 0\\r\\n\\r\\n for ip, p in enumerate(prio):\\r\\n for ipl, pl in enumerate(placement):\\r\\n for ic, c in enumerate(costFunction):\\r\\n if p != 'BIL' or c == 'mean' or pl in ['DL', 'GDL']:\\r\\n for idd, d in enumerate(desc):\\r\\n for iu, u in enumerate(useOfBIM):\\r\\n for ii, i in enumerate(insertion):\\r\\n for ib, b in enumerate(BSA):\\r\\n cnt += 1\\r\\n name = \\\";\\\".join(map(str, [ip, ic, ipl, idd, iu, ii, ib]))\\r\\n\\r\\n # dispName = \\\"-\\\".join(map(str, [p, pl, c, d, u, i, b]))\\r\\n # print(\\\"Heuristic n°\\\", cnt, \\\"-\\\", dispName)\\r\\n # print(\\\"Heuristic n°\\\", cnt, \\\"-\\\", name)\\r\\n\\r\\n startScheduling = timeit.default_timer()\\r\\n try:\\r\\n schedule = computeSchedule(g, strategyPrio=p, costFunction=c,\\r\\n strategyPlacement=pl,\\r\\n useOfBIM=u, desc=d,\\r\\n insertion=i, bsa=b, verbose=verbose)\\r\\n verifPrec(g, schedule, verbose)\\r\\n endScheduling = timeit.default_timer()\\r\\n # print(\\\"Ended in :\\\", 1000*(endScheduling - startScheduling), \\\"ms\\\")\\r\\n # print(\\\"Ended in :\\\", round(1000 * (endScheduling - startScheduling),2), \\\"ms\\\")\\r\\n timeS = round(1000 * (endScheduling - startScheduling), 2)\\r\\n # print(f\\\"timeS : {timeS}\\\")\\r\\n if verbose:\\r\\n print(f\\\"Time : {timeS}ms\\\")\\r\\n res[name] = [round(schedule[getExitTask(g)][2], 6), timeS]\\r\\n except Exception as _:\\r\\n\\r\\n print(\\\"Error for : \\\" + name + \\\" on file \\\" + graphname)\\r\\n file = open(\\\"error.log\\\", 'a')\\r\\n file.write(f\\\"Error for {name} on file {graphname}\\\\n\\\")\\r\\n file.close()\\r\\n raise _\\r\\n return res\\r\\n return res\",\n \"def main():\\n test_file = 'lib/pbk411.tsp'\\n limit = 1000\\n milestones = [10, 25, 100, 500, 1000]\\n\\n lx, ly = parse_data(test_file)\\n algo = Genalgo(lx, ly)\\n current = 0\\n\\n for i in range(0, limit):\\n algo.evolve_new_pop(i)\\n if i == milestones[current]:\\n cities, distance = get_best(algo)\\n cities.append(cities[0])\\n make_plot_solved(lx, ly, cities)\\n save_plot('solved-' + str(milestones[current]) + '.png')\\n print(str(milestones[current]) + ': ' + str(distance))\\n current += 1\\n\\n _, best_tuple = algo.get_best_tours(algo.tours)\\n best = algo.tours[best_tuple[0]]\\n cities = best.cities\\n cities.append(best.cities[0])\\n print('Best: ' + str(best.get_cost()))\\n\\n make_plot_original(lx, ly)\\n save_plot('original.png')\\n make_plot_solved(lx, ly, cities)\\n save_plot('solved.png')\",\n \"def getHeuristicSolutions(distance,countryNo,heurNo):\\n if heurNo>countryNo:\\n print \\\"WARNING: There might be no sense that heurNo > countryNo. There would be repetition\\\"\\n heuristicPop = []\\n for ii in range(heurNo):\\n # Copy distance list\\n tempdist = copy.deepcopy(distance)\\n # Pick one guy\\n basicPerm = range(countryNo)\\n heur = []\\n luckyGuy = random.sample(basicPerm,1)[0]\\n basicPerm.remove(luckyGuy)\\n heur.append(luckyGuy)\\n # Get closest neighbour\\n for i in range(countryNo-1):\\n minval = min(tempdist[luckyGuy][:])\\n oldGuy = luckyGuy\\n luckyGuy = tempdist[luckyGuy].index(minval)\\n basicPerm.remove(luckyGuy)\\n heur.append(luckyGuy)\\n for jj in range(countryNo):\\n tempdist[oldGuy][jj] = inf\\n tempdist[jj][oldGuy] = inf\\n ind = heur.index(0)\\n heur = [heur[(it+ind)%countryNo] for it in range(countryNo)]\\n heuristicPop.append(heur)\\n return heuristicPop\",\n \"def heuristic(current, goal):\\r\\n # return 1\\r\\n i = current[0] - goal[0]\\r\\n j = current[1] - goal[1]\\r\\n return math.sqrt(math.pow(i,2) + math.pow(j,2)) # Your code here\\r\\n # return math.fabs(current[0] - goal[0]) + math.fabs(current[1] - goal[1])\\r\",\n \"def heuristic_function_hard(node, current_player):\\n alpha = 25\\n beta = 10\\n gamma = 40\\n delta = -200\\n\\n x, y = node.get_neutron_coordinates()\\n\\n # Calculates the distance between the neutron and the player's home rank\\n # and calculates how many paths exist for the neutron to reach the player's home rank\\n # as well as for the opponent\\n if current_player == PLAYER_A:\\n neutron_distance = y\\n\\n player_paths = get_number_of_paths(node, x, y, PLAYER_A)\\n opponent_paths = get_number_of_paths(node, x, y, PLAYER_B)\\n\\n else:\\n neutron_distance = node.board_size - y\\n\\n player_paths = get_number_of_paths(node, x, y, PLAYER_B)\\n opponent_paths = get_number_of_paths(node, x, y, PLAYER_A) \\n\\n surrounding_soldiers = 0\\n\\n # Calculates the number of surrounding soldiers\\n for j in range(-1, 2):\\n for i in range(-1, 2):\\n\\n if x + i < 0 or x + i >= node.board_size or y + j < 0 or y + j >= node.board_size:\\n continue\\n elif node.board[y+j][x+i] == PLAYER_A_SOLDIER_CHAR or node.board[y+j][x+i] == PLAYER_B_SOLDIER_CHAR:\\n surrounding_soldiers += 1\\n\\n return alpha*neutron_distance + beta*surrounding_soldiers + gamma*player_paths + delta*opponent_paths\",\n \"def heuristic_main(data):\\n arcs, nodes, periods = data.arcs.size, data.nodes, data.periods\\n commodities = data.commodities\\n arc_origins, arc_destinations = get_2d_index(data.arcs, nodes)\\n\\n model = make_model(data)\\n\\n open_arcs = np.zeros((periods, arcs), dtype=np.double)\\n\\n objective = 0.\\n\\n for t in xrange(periods):\\n fixed_cost, variable_cost = data.fixed_cost[t, :], data.variable_cost\\n demand = data.demand[t, :]\\n flow, arc_open = model._flow, model._arc_open\\n\\n for arc in xrange(arcs):\\n i, j = arc_origins[arc], arc_destinations[arc]\\n con_name = 'cap_{}-{}'.format(i, j)\\n con = model.getConstrByName(con_name)\\n # We pay for arcs that are not already open\\n if arc_open[arc].lb == 0:\\n arc_open[arc].obj = fixed_cost[arc]\\n for c in xrange(commodities):\\n model.chgCoeff(con, flow[c, arc], demand[c])\\n flow[c, arc].obj = variable_cost[arc] * demand[c]\\n model.optimize()\\n if model.status == grb.GRB.status.INFEASIBLE:\\n model.computeIIS()\\n print 'model is infeasible'\\n model.write(str(model.ModelName) + '_{}.ilp'.format(t))\\n if model.SolCount > 0:\\n objective += model.objVal\\n # If we use an arc and it has not been opened before, we should\\n # mark it as open now, and keep it open all along\\n for count, var in enumerate(arc_open):\\n if var.X > 0.1:\\n var.lb = 1.\\n var.obj = 0.\\n if np.sum(open_arcs[:t, count]) < 10e-5:\\n open_arcs[t, count] = 1.\\n print 'Period : {} Objective value: {}'.format(t, objective)\\n\\n return objective, open_arcs\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # Priority Queue to hold the node along with the path taken from the start node to reach that node\\n pqueue = PriorityQueue()\\n #Set to hold the node explored.\\n explorednode = set()\\n # Get the start node.\\n startnode = problem.getStartState()\\n # Push the starting node on the Queue along with an empty set to know the direction in order to reach the node.\\n pqueue.push((startnode, []), 0)\\n\\n # Loop till the priority queue is empty\\n while pqueue.isEmpty() is not True:\\n # Pop the currentnode and the direction from the priority queue\\n (currentnode, direction) = pqueue.pop()\\n # Check if the currentnode is not in the explored node.\\n if currentnode not in explorednode:\\n # We will now add the node to set of explored node.\\n explorednode.add(currentnode)\\n # If the node is the goal. We made it!!\\n if problem.isGoalState(currentnode):\\n # The direction holds the way to reach till the goal from the start node.\\n return direction\\n # Loop for each successor(child) of the current node.\\n for (successor, action, stepCost) in problem.getSuccessors(currentnode):\\n # Add the successor to the queue along with the path to reach it.\\n if successor not in explorednode:\\n # Add the successor to the queue along with the path to reach it.\\n pqueue.push((successor, direction + [action]), problem.getCostOfActions(direction + [action]) + heuristic(successor, problem))\\n util.raiseNotDefined()\",\n \"def enforced_hillclimbing_search(planning_task, heuristic,\\n use_preferred_ops=False):\\n # counts the number of loops (only for printing)\\n iteration = 0\\n # fifo-queue storing the nodes which are next to explore\\n queue = deque()\\n initial_node = searchspace.make_root_node(planning_task.initial_state)\\n queue.append(initial_node)\\n best_heuristic_value = heuristic(initial_node)\\n logging.info(\\\"Initial h value: %f\\\" % best_heuristic_value)\\n # set storing the explored nodes, used for duplicate detection\\n closed = set()\\n visited = set()\\n while queue:\\n iteration += 1\\n # get the next node to explore\\n node = queue.popleft()\\n # remember the successor state\\n closed.add(node.state)\\n visited.add(node.state)\\n # exploring the node or if it is a goal node extracting the plan\\n if planning_task.goal_reached(node.state):\\n logging.info(\\\"Goal reached. Start extraction of solution.\\\")\\n logging.info(\\\"%d Nodes expanded\\\" % len(visited))\\n return node.extract_solution()\\n\\n # for the preferred operator version --> recompute heuristic and\\n # relaxed plan\\n if use_preferred_ops:\\n (rh, rplan) = heuristic.calc_h_with_plan(node)\\n logging.debug(\\\"relaxed plan %s \\\" % rplan)\\n\\n for operator, successor_state in planning_task.get_successor_states(\\n node.state):\\n\\n # for the preferred operator version ignore all non preferred\\n # operators\\n if use_preferred_ops:\\n if rplan and not operator.name in rplan:\\n # ignore this operator if we use the relaxed plan criterion\\n logging.debug('removing operator %s << not a preferred '\\n 'operator' % operator.name)\\n continue\\n else:\\n logging.debug('keeping operator %s' % operator.name)\\n\\n # duplicate detection\\n if successor_state not in closed:\\n successor_node = searchspace.make_child_node(node, operator,\\n successor_state)\\n heuristic_value = heuristic(successor_node)\\n if heuristic_value == float('inf'):\\n continue\\n elif heuristic_value < best_heuristic_value:\\n # Just take the first successor node that has a lower\\n # heuristic value than the current best_heuristic_value\\n # and ignore the other successor nodes.\\n logging.debug(\\\"Found new best h: %f after %d expansions\\\" %\\n (heuristic_value, iteration))\\n queue.clear()\\n closed.clear()\\n best_heuristic_value = heuristic_value\\n queue.append(successor_node)\\n break\\n else:\\n queue.append(successor_node)\\n logging.info(\\\"No operators left. Task unsolvable.\\\")\\n logging.info(\\\"%d Nodes expanded\\\" % len(visited))\\n return None\",\n \"def solve(self):\\r\\n while not self.done():\\r\\n self.no_open_cells()\\r\\n self.all_cells_are_mines()\\r\\n self.no_mines()\\r\\n if not self.done():\\r\\n self.obvious_cells()\\r\\n if not self.done():\\r\\n made_progress = self.safe_neighbour_difference()\\r\\n if made_progress:\\r\\n continue\\r\\n if not self.done():\\r\\n made_progress = self.adjacent_combinations()\\r\\n if made_progress:\\r\\n continue\\r\\n return\",\n \"def solve(self, state, times):\",\n \"def solve(num_wizards, num_constraints, wizards, constraints):\\n print(\\\"starting time\\\")\\n start = time.time()\\n print(\\\"hello\\\")\\n end = time.time()\\n print(\\\"time taken\\\",end - start)\\n random.shuffle(wizards)\\n assignment = wizards\\n loop_counter = 0\\n temperature = 10.0\\n while not numSat(constraints, assignment) == len(constraints):\\n loop_counter += 1\\n if loop_counter % 500 == 0:\\n print(\\\"numSat\\\", numSat(constraints, assignment))\\n print(\\\"loops\\\",loop_counter)\\n print(\\\"time taken\\\", time.time()-start)\\n a = random.sample([i for i in range(len(wizards))], 1)\\n b = random.sample([i for i in range(len(wizards))], 1)\\n new_assignment = swap(assignment, a[0], b[0])\\n delta = numSat(constraints, assignment) - numSat(constraints, new_assignment)\\n if delta < 0:\\n print(\\\"delta negative\\\")\\n assignment = new_assignment\\n else: \\n # print(\\\"sample greater than expo\\\")\\n sample = random.uniform(0.0,1.0)\\n expo = np.exp(-1*float(delta) / temperature)\\n if sample < expo:\\n # print(\\\"sample less than expo\\\")\\n assignment = new_assignment\\n temperature -= 0.2\\n\\n print(\\\"Solved BITCH! numSat:\\\", numSat(constraints, assignment))\\n return assignment\",\n \"def nearest_neighbor(FILE_NAME):\\n time_0 = DEFAULT_TIMER()\\n list_of_cities = read_in_file(FILE_NAME)\\n best_opt_distance = sys.maxsize\\n best_sol_of_cities = []\\n\\n for city in list_of_cities: #iterate through all cities in the list\\n for resetCity in list_of_cities: #reset them all to not visited\\n resetCity[3] = False\\n sol_of_cities = [] #set our current solution to empty\\n opt_distance = 0 #reset our current optimal solution\\n nearest_dist = sys.maxsize #nearest distance is huge\\n nearest_city = 0\\n first_city = city #the first city visited is the next city in our iteration\\n first_city[3] = True\\n sol_of_cities.append(first_city[0])\\n\\n city_1 = first_city\\n\\n while len(sol_of_cities) < len(list_of_cities): #check the current city to\\n #find the closest city in the\\n #list of cities not visited\\n nearest_dist = sys.maxsize\\n for city_2 in list_of_cities:\\n #if the two cities are not the same and have not visited the second city\\n if city_1[0] != city_2[0] and city_2[3] != True:\\n dx = city_1[1] - city_2[1]\\n dy = city_1[2] - city_2[2]\\n dist_to = int(round(math.sqrt((dx*dx) + (dy*dy))))\\n #update nearest_city if the new distance is less than the current nearest distance\\n if dist_to < nearest_dist:\\n nearest_dist = dist_to\\n nearest_city = city_2\\n#add the city only if we haven't already visited it. Had a wierd bug need to investigate this further\\n if nearest_city[3] != True: \\n sol_of_cities.append(nearest_city[0])\\n opt_distance += nearest_dist\\n nearest_city[3] = True\\n city_1 = nearest_city\\n #quit if our distance is larger than our best solution found\\n if(opt_distance > best_opt_distance):\\n #print(\\\"quit this search\\\") #comment out, see skipped searches\\n break\\n#add the distance from the last city we visited back to the first city to make a tour\\n dx = nearest_city[1] - first_city[1]\\n dy = nearest_city[2] - first_city[2]\\n opt_distance += int(round(math.sqrt((dx*dx) + (dy*dy))))\\n#if our current solution is better than the previous solution replace it, then start over until we've checked all cities\\n if best_opt_distance > opt_distance:\\n best_opt_distance = opt_distance\\n best_sol_of_cities = sol_of_cities\\n #print(best_sol_of_cities) #can remove later for testing now\\n #print(best_opt_distance) #same as above\\n \\n write_to_file(best_sol_of_cities, best_opt_distance, FILE_NAME)\\n time_1 = DEFAULT_TIMER()\\n print(\\\"Time taken: \\\", (time_1 - time_0))\",\n \"def AStar_search(problem, heuristic=nullHeuristic):\\n root_node = Node(problem.getStartState(), [], 0, None, 0)\\n frontier = util.PriorityQueue()\\n frontier.push(root_node, 0 + heuristic(root_node.state, problem))\\n explored = []\\n nodes_list = list(problem.G.nodes)\\n # heuristic_value = [heuristic(x,problem) for x in nodes_list]\\n # print problem.start_node\\n # print problem.end_node\\n while not(frontier.isEmpty()):\\n\\n \\tnode_to_explore = frontier.pop()\\n \\tif problem.isGoalState(node_to_explore.state):\\n \\t\\t# recontruct_path\\n \\t\\t# print \\\"Some thing\\\"\\n \\t\\t# print node_to_explore.parent_node.state\\n \\t\\troute_list = [node_to_explore.state]\\n \\t\\tparent = node_to_explore.parent_node\\n \\t\\twhile parent != None:\\n \\t\\t\\troute_list.append(parent.state)\\n \\t\\t\\tparent = parent.parent_node\\n \\t\\troute_list.reverse()\\n \\t\\t# print route_list\\n \\t\\treturn route_list\\n \\telse:\\n\\t\\t\\tcopy_state = node_to_explore.state\\n\\t\\t\\t# successors_state = problem.getSuccessors(copy_state)\\n\\t\\t\\tif copy_state not in explored:\\n\\t\\t\\t\\texplored.append(copy_state)\\n\\t\\t\\t\\tsuccessors_state = problem.getSuccessors(copy_state)\\n\\t\\t\\t\\tif len(successors_state) > 0:\\n\\t\\t\\t\\t\\tfor suc_act_cost in successors_state:\\n\\t\\t\\t\\t\\t\\tif suc_act_cost[0] in explored:\\n\\t\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tcost = node_to_explore.path_cost + suc_act_cost[2]\\n\\t\\t\\t\\t\\t\\t\\tcost_with_heuristic = cost + heuristic(suc_act_cost[0], problem)\\n\\t\\t\\t\\t\\t\\t\\tfrontier.update(Node(suc_act_cost[0], suc_act_cost[1], cost , node_to_explore, node_to_explore.depth + 1), cost_with_heuristic)\\n\\t\\t # util.raiseNotDefined()\\n # print len(explored)\",\n \"def tinyMazeSearch(problem):\\r\\n from game import Directions\\r\\n s = Directions.SOUTH\\r\\n w = Directions.WEST\\r\\n return [s,s,w,s,w,w,s,w]\",\n \"def solution(map):\\n # length[i][j] = the length of the shortest path from (i,j) to (w-1,h-1).\\n # Modify the current location to -1 and continue searching from adjacent spaces.\\n return Maze(map).shortest_length()\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s,s,w,s,w,w,s,w]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6477208","0.63721377","0.63295656","0.6317618","0.62916344","0.6283113","0.62769455","0.627362","0.6254762","0.62242985","0.6224087","0.61772007","0.6172025","0.61346906","0.61340076","0.611956","0.6112025","0.6105103","0.6101848","0.60936993","0.6079271","0.60660696","0.60629904","0.6054157","0.6012235","0.5995453","0.59738094","0.5963384","0.5945567","0.59323055","0.5922658","0.59207404","0.5917356","0.59149796","0.5914612","0.59135294","0.591233","0.5901213","0.5895994","0.5886534","0.58850765","0.58831","0.5880186","0.58771837","0.58654183","0.58575517","0.58545274","0.5850061","0.5847871","0.5844015","0.5835208","0.5819051","0.5817644","0.581184","0.58024114","0.58018214","0.57894444","0.5784356","0.57834005","0.5782884","0.5781991","0.57741857","0.57591593","0.57580763","0.57558095","0.5743955","0.5739999","0.5737004","0.5735028","0.5725779","0.5724193","0.5716314","0.5710128","0.57095087","0.57028645","0.57005465","0.5699905","0.56947476","0.5692983","0.5680459","0.5680327","0.5677462","0.5675196","0.56748766","0.56691664","0.56674784","0.5666143","0.5660796","0.56602615","0.565768","0.5652933","0.56449","0.5642902","0.5639147","0.56346256","0.5632984","0.56283593","0.5625033","0.5623347","0.5622819"],"string":"[\n \"0.6477208\",\n \"0.63721377\",\n \"0.63295656\",\n \"0.6317618\",\n \"0.62916344\",\n \"0.6283113\",\n \"0.62769455\",\n \"0.627362\",\n \"0.6254762\",\n \"0.62242985\",\n \"0.6224087\",\n \"0.61772007\",\n \"0.6172025\",\n \"0.61346906\",\n \"0.61340076\",\n \"0.611956\",\n \"0.6112025\",\n \"0.6105103\",\n \"0.6101848\",\n \"0.60936993\",\n \"0.6079271\",\n \"0.60660696\",\n \"0.60629904\",\n \"0.6054157\",\n \"0.6012235\",\n \"0.5995453\",\n \"0.59738094\",\n \"0.5963384\",\n \"0.5945567\",\n \"0.59323055\",\n \"0.5922658\",\n \"0.59207404\",\n \"0.5917356\",\n \"0.59149796\",\n \"0.5914612\",\n \"0.59135294\",\n \"0.591233\",\n \"0.5901213\",\n \"0.5895994\",\n \"0.5886534\",\n \"0.58850765\",\n \"0.58831\",\n \"0.5880186\",\n \"0.58771837\",\n \"0.58654183\",\n \"0.58575517\",\n \"0.58545274\",\n \"0.5850061\",\n \"0.5847871\",\n \"0.5844015\",\n \"0.5835208\",\n \"0.5819051\",\n \"0.5817644\",\n \"0.581184\",\n \"0.58024114\",\n \"0.58018214\",\n \"0.57894444\",\n \"0.5784356\",\n \"0.57834005\",\n \"0.5782884\",\n \"0.5781991\",\n \"0.57741857\",\n \"0.57591593\",\n \"0.57580763\",\n \"0.57558095\",\n \"0.5743955\",\n \"0.5739999\",\n \"0.5737004\",\n \"0.5735028\",\n \"0.5725779\",\n \"0.5724193\",\n \"0.5716314\",\n \"0.5710128\",\n \"0.57095087\",\n \"0.57028645\",\n \"0.57005465\",\n \"0.5699905\",\n \"0.56947476\",\n \"0.5692983\",\n \"0.5680459\",\n \"0.5680327\",\n \"0.5677462\",\n \"0.5675196\",\n \"0.56748766\",\n \"0.56691664\",\n \"0.56674784\",\n \"0.5666143\",\n \"0.5660796\",\n \"0.56602615\",\n \"0.565768\",\n \"0.5652933\",\n \"0.56449\",\n \"0.5642902\",\n \"0.5639147\",\n \"0.56346256\",\n \"0.5632984\",\n \"0.56283593\",\n \"0.5625033\",\n \"0.5623347\",\n \"0.5622819\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.63413787"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":24598,"cells":{"query":{"kind":"string","value":"Given the solution saved in list, calculate the total cost of the solution. Write the solution to local in the required format."},"document":{"kind":"string","value":"def print_result(self, solution, vehicle_type, if_write):\r\n\r\n result = [['Vehicle_ID', 'Vehicle_type', 'Route', 'Leave_Time', 'Back_Time', 'Work_Time', 'Distance',\r\n 'Load_Volume', 'Wait_Time', 'Fixed_Cost', 'Travel_Cost', 'Total_Cost']]\r\n total_dist = 0\r\n total_cost = 0\r\n for k, veh in enumerate(solution):\r\n if len(veh) == 2:\r\n continue\r\n\r\n if vehicle_type[k] == 2:\r\n trans0 = small_veh[4]\r\n fix0 = small_veh[5]\r\n elif vehicle_type[k] == 3:\r\n trans0 = medium_veh[4]\r\n fix0 = medium_veh[5]\r\n else:\r\n trans0 = large_veh[4]\r\n fix0 = large_veh[5]\r\n\r\n total_cost += fix0\r\n departt = check_violation(veh, vehicle_type[k])[3]\r\n\r\n trvl_dist = 0\r\n veh_load_vol = 0\r\n wait_time = 0\r\n\r\n # get the output format\r\n route = [0] * len(result[0])\r\n route[0] = k + 1 # vehicle name\r\n route[1] = vehicle_type_dict[vehicle_type[k]] # vehicle type\r\n route_ele = []\r\n for ele in veh:\r\n if ele == 0:\r\n route_ele.append(str(ele))\r\n else:\r\n route_ele.append(num_id[ele][0])\r\n route[2] = '-'.join(route_ele) # route\r\n\r\n trvl_dist += (dist_mat[0, veh[1]] + dist_mat[veh[-2], 0])\r\n veh_load_vol += (num_demd[veh[1]][0] * bskt_vol + num_demd[veh[1]][1] * trsf_vol + (num_demd[veh[1]][2] +\r\n num_demd[veh[1]][3]) * milk_vol + num_demd[veh[1]][4] * paper_bskt)\r\n if departt / 60. < 24.:\r\n out_time = int(departt)\r\n else:\r\n out_time = int(departt - 24 * 60)\r\n route[3] = str(out_time // 60) + ':' + str(out_time % 60).zfill(2)\r\n t = departt + time_mat[0, veh[1]] + oprt_t\r\n for i in range(2, len(veh) - 1): # can not wait at the first 2 points\r\n trvl_dist += dist_mat[veh[i - 1], veh[i]]\r\n veh_load_vol += (num_demd[veh[i]][0] * bskt_vol + num_demd[veh[i]][1] * trsf_vol + (num_demd[veh[i]][2] +\r\n num_demd[veh[i]][3]) * milk_vol + num_demd[veh[i]][4] * paper_bskt)\r\n wait_t = num_timez[veh[i]][0] - (t + time_mat[veh[i - 1], veh[i]])\r\n if wait_t > 0 + 1e-5:\r\n # print veh[i-1], veh[i], wait_t\r\n wait_time += wait_t\r\n t = num_timez[veh[i]][0] + oprt_t\r\n else:\r\n t += (time_mat[veh[i - 1], veh[i]] + oprt_t)\r\n if t + time_mat[veh[-2], 0] < 24. * 60:\r\n in_time = int(t + time_mat[veh[-2], 0])\r\n else:\r\n in_time = int(t + time_mat[veh[-2], 0] - 24 * 60)\r\n\r\n route[4] = str(in_time // 60) + ':' + str(in_time % 60).zfill(2) # vehicle back time\r\n route[5] = round((t + time_mat[veh[-2], 0] - departt) / 60., 1)\r\n route[6] = round(trvl_dist / 1000., 2) # total distance\r\n route[7] = veh_load_vol # vehicle load volume\r\n route[8] = wait_time # vehicle wait time\r\n route[9] = fix0 # vehicle fixed cost\r\n route[10] = round(trvl_dist * trans0, 2) # vehicle travel cost\r\n route[11] = route[9] + route[10] # total cost\r\n\r\n total_cost += trvl_dist * trans0\r\n result.append(route)\r\n # print route\r\n total_dist += route[6]\r\n # print 'Last leave time: ', int(t) / 60, ':', int(t) % 60\r\n # print 'total distances: ', route[5]\r\n\r\n if if_write:\r\n run_time = time.strftime(\"%m%d_%H%M\", time.localtime())\r\n with open(r'C:\\Bee\\0Huaat\\Starbucks\\results\\Route_Plan_%s.csv' % run_time, 'w', newline='') as fw:\r\n writer = csv.writer(fw)\r\n for v in result:\r\n writer.writerow(v)\r\n\r\n return round(total_cost, 2)"},"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 print_and_save_solution(data, manager, routing, assignment):\n total_distance = 0\n total_load = 0\n routes = []\n for vehicle_id in range(data['num_vehicles']):\n route = []\n index = routing.Start(vehicle_id)\n plan_output = 'Route for vehicle {}:\\n'.format(vehicle_id)\n route_distance = 0\n route_load = 0\n while not routing.IsEnd(index):\n node_index = manager.IndexToNode(index)\n route_load += data['demands'][node_index]\n plan_output += ' {0} Load({1}) -> '.format(node_index, route_load)\n previous_index = index\n index = assignment.Value(routing.NextVar(index))\n route_distance += routing.GetArcCostForVehicle(\n previous_index, index, vehicle_id)\n point = data['all_points'][node_index]\n point['load'] = route_load\n route.append(point)\n plan_output += ' {0} Load({1})\\n'.format(manager.IndexToNode(index),\n route_load)\n plan_output += 'Distance of the route: {}m\\n'.format(route_distance)\n plan_output += 'Load of the route: {}\\n'.format(route_load)\n print(plan_output)\n total_distance += route_distance\n total_load += route_load\n if route_load > 0:\n routes.append({\n 'stops': route,\n 'distance': route_distance,\n 'load': route_load,\n 'number_of_stops': len(route)\n })\n print('Total distance of all routes: {}m'.format(total_distance))\n print('Total load of all routes: {}'.format(total_load))\n with open('./results/capacity_{}_{}.json'.format(DRONES_CAPACITY, MAX_POINT_DEMAND), 'w') as f:\n simplejson.dump({\n 'routes': routes,\n 'total_load': total_load,\n 'total_distance': total_distance,\n 'number_of_drones_used': len(routes),\n 'total_numer_of_stops': sum([x['number_of_stops'] for x in routes])\n }, f)","def calculateCost(self,sol,weights):\n\t\treturn sum([x.value*y if x != None else 0 \\\n\t\t\t\t\tfor x,y in zip(sol,weights)])","def add_cost(costs, cost, FILE):\r\n costs.append(cost)\r\n save_list_json(costs, FILE)\r\n return costs","def total_cost_2D(self, final_list):\n total_cost = 0\n for i in range(len(final_list) - 1):\n temp = self.pairwise_distance(final_list[i], final_list[i + 1])\n total_cost = total_cost + temp\n print(\"Total distance: \" + str(total_cost))","def cost(self) -> float:","def calculate_total_cost(state):\n pass","def print_solution(data, manager, routing, assignment):\n total_distance = 0\n total_load = 0\n for vehicle_id in range(data['num_vehicles']):\n index = routing.Start(vehicle_id)\n plan_output = 'Route for vehicle {}:\\n'.format(vehicle_id)\n route_distance = 0\n route_load = 0\n while not routing.IsEnd(index):\n node_index = manager.IndexToNode(index)\n route_load += data['demands'][node_index]\n plan_output += ' {0} Load({1}) -> '.format(node_index, route_load)\n previous_index = index\n index = assignment.Value(routing.NextVar(index))\n route_distance += routing.GetArcCostForVehicle(\n previous_index, index, vehicle_id)\n plan_output += ' {0} Load({1})\\n'.format(manager.IndexToNode(index),\n route_load)\n plan_output += 'Distance of the route: {}m\\n'.format(route_distance)\n plan_output += 'Load of the route: {}\\n'.format(route_load)\n # print(plan_output)\n total_distance += route_distance\n total_load += route_load\n with open(f\"Survey/vrp-nanostores/vrp-nanostores/food_deserts/outputs/2-e/clust8/route/route_vehicle{vehicle_id}.txt\", \"w\") as file:\n file.write(plan_output)\n file.close()\n print(\"aaa\")\n print('Total cost for all routes: {}m'.format(total_distance))\n print('Total load of all routes: {}'.format(total_load))\n with open(f\"Survey/vrp-nanostores/vrp-nanostores/food_deserts/outputs/2-e/clust8/load_dist_{data['num_vehicles']}vehicles.txt\", \"w\") as file:\n out_file = \"\"\n out_file += str(total_load) + \",\" + str(total_distance)\n file.write(out_file)\n file.close() # OPEN AND ANALYZE LATER WITH PANDAS","def calculate_total_cost(state):\r\n return state.cost()","def evaluate(self, solution: list) -> (float, float):\n start = time() * 1000\n # get the total distance without return\n total_dist = 0\n for idx, node in enumerate(solution[:-1]):\n dist = self.application[solution[idx + 1]][solution[idx]]\n total_dist += dist['weight']\n\n logging.info(f\"Total distance (without return): {total_dist}\")\n\n # add distance between start and end point to complete cycle\n return_distance = self.application[solution[0]][solution[-1]]['weight']\n # logging.info('Distance between start and end: ' + return_distance)\n\n # get distance for full cycle\n distance_with_return = total_dist + return_distance\n logging.info(f\"Total distance (including return): {distance_with_return}\")\n\n return distance_with_return, round(time() * 1000 - start, 3)","def cost(self, route: List[int]) -> float:\n raise NotImplementedError","def evaluate(self, solution, total = 0):\n for objective in self.objectives:\n total = total + objective(solution)\n return total","def file_cost(filename):\r\n return grid_cost(read_grid(filename))","def file_cost(filename):\r\n return grid_cost(read_grid(filename))","def total_cost(self):\n path = self.bidirectional_cpp.getPath()\n return self.bidirectional_cpp.getTotalCost() if len(path) > 0 else None","def finish(outFileName, startTime, ans):\n out_ = open(outFileName, \"w\")\n out_.write(\"%d\\n\" %ans[\"cost\"])\n if len(ans[\"path\"]) > 0:\n s = \"\"\n for n in ans[\"path\"]:\n s += str(n) + \" \"\n s += str(ans[\"path\"][0])\n out_.write(s)\n out_.close()\n print(\"Cost: %d\" %ans[\"cost\"])\n print(\"Finished in %f seconds\" %(time.time()-startTime))","def cost(inventory):\n return inventory.reduce(convert.get_cost)","def print_solution(data, manager, routing, assignment):\r\n total_distance = 0\r\n total_load = 0\r\n # setting the route for each vehicle \r\n file = open('plan_outputGLS.txt','w')\r\n for vehicle_id in range(data['num_vehicles']):\r\n index = routing.Start(vehicle_id)\r\n plan_output = 'Route for vehicle {}:\\n'.format(vehicle_id)\r\n route_distance = 0\r\n route_load = 0\r\n while not routing.IsEnd(index):\r\n node_index = manager.IndexToNode(index)\r\n route_load += data['demands'][node_index]\r\n plan_output += ' {0} Load({1}) -> '.format(node_index, route_load)\r\n previous_index = index\r\n index = assignment.Value(routing.NextVar(index))\r\n route_distance += routing.GetArcCostForVehicle(\r\n previous_index, index, vehicle_id)\r\n plan_output += ' {0} Load({1})\\n'.format(\r\n manager.IndexToNode(index), route_load)\r\n plan_output += 'Distance of the route: {}m\\n'.format(route_distance)\r\n plan_output += 'Load of the route: {}\\n'.format(route_load)\r\n print(plan_output)\r\n file.write(plan_output)\r\n total_distance += route_distance\r\n total_load += route_load\r\n print('Total distance of all routes: {}m'.format(total_distance))\r\n print('Total load of all routes: {}'.format(total_load))\r\n file.write('Total distance of all routes: {}m'.format(total_distance))\r\n file.write('Total load of all routes: {}'.format(total_load))\r\n file.close()","def get_score(self, solution: np.array) -> float:\n score = 0\n for vehicle_count, vehicle_solution in enumerate(solution):\n distances = self.distance_matrix[vehicle_solution[0:-1], vehicle_solution[1:]]\n costs = distances * self.selected_transportation_cost[vehicle_count]\n score += np.sum(costs)\n return score","def local_cost(self) -> Number:\n mu_E = self._payoff_weight_energy\n mu_T = self._payoff_weight_time\n D_loc = SIMULATION_PARAMETERS['LOCAL_CPU_CYCLES']\n F_loc = self.cpu_frequency\n T_loc = D_loc / F_loc\n E_loc = D_loc / self.cpu_effeciency\n return mu_T * T_loc + mu_E * E_loc","def calculate_training_cost(soldier_list: List[Soldier]):\n total_cost = 0.0\n \n for soldier in soldier_list:\n ################################# YOUR CODE HERE #################################\n if soldier.typecode == \"INF\":\n cost = 2.5 * soldier.weapon + 1.0 * soldier.armor\n elif soldier.typecode == \"ARC\":\n cost = 1.5 * soldier.weapon + 3.0 * soldier.armor\n elif soldier.typecode == \"CVL\":\n cost = 4.0 * soldier.weapon + 6.0 * soldier.armor\n if soldier.vitality < 0.35:\n cost *= 0.5\n total_cost += cost\n ##################################################################################\n return total_cost","def total_cost(self, data, lmbda, convert=False):\n cost = 0.0\n for x, y in data:\n a = self.feedforward(x)\n if convert: y = vectorized_result(y)\n cost += self.cost.fn(a, y)/len(data)\n cost += 0.5*(lmbda/len(data))*sum(\n np.linalg.norm(w)**2 for w in self.weights)\n return cost","def _compute_calculate_cost(self):\n for order in self:\n amount_calculate_cost = 0.0\n for line in order.order_line:\n amount_calculate_cost += (line.product_id.standard_price * line.product_uom_qty)\n order.update({\n 'amount_calculate_cost': amount_calculate_cost\n })","def update(self, solution):\n self.heuristic_path = [i for i in self.initial_path if i in solution]\n self.heuristic_cost = self.pathCost(self.heuristic_path)","def print_solution(self):\n print(f'Objective: {self.solution.ObjectiveValue()}')\n total_distance = 0\n total_load = 0\n max_route_distance = 0\n for vehicle_id in range(self.data['num_vehicles']):\n index = self.routingManager.Start(vehicle_id)\n plan_output = 'Route for vehicle {}:\\n'.format(vehicle_id)\n route_distance = 0\n route_load = 0\n while not self.routingManager.IsEnd(index):\n node_index = self.manager.IndexToNode(index)\n route_load += self.data['demands'][node_index]\n plan_output += ' {0} Load({1}) -> '.format(self.data['names'][node_index], route_load)\n\n previous_index = index\n index = self.solution.Value(self.routingManager.NextVar(index))\n route_distance += self.routingManager.GetArcCostForVehicle(\n previous_index, index, vehicle_id\n )\n print(route_distance)\n\n plan_output += '{0}, Load({1}) \\n '.format(self.data['names'][self.manager.IndexToNode(index)], route_load)\n\n plan_output += 'Distance of the route: {}\\n'.format(route_distance)\n plan_output += 'Load of the route: {}\\n'.format(route_load)\n\n print(plan_output)\n total_distance += route_distance\n total_load += route_load\n\n print('Total distance of all routes: {}km'.format(total_distance))\n print('Total load of all routes: {}'.format(total_load))","def save_solution(self, solution_path, file_path):\n node_info = \"\"\n with open(file_path, \"w\") as file:\n file.write(\n \"Strategy: \"\n + str(self.strategy)\n + \"\\n Max Depth: \"\n + str(self.max_depth)\n + \"\\n Depth Increment: \"\n + str(self.depth_increment)\n + \"\\n Pruning: \"\n + str(self.pruning)\n + \"\\n ---SOLUTION---: \"\n )\n for node in solution_path:\n node_info = \"\\n\\n ID: \" + str(node.id)\n if node.last_action != None:\n node_info += \"\\n Action: \" + str(node.last_action)\n node_info += (\n \"\\n Cost: \"\n + str(node.cost)\n + \"\\n Depth: \"\n + str(node.node_depth)\n + \"\\n Heuristic: \"\n + str(node.state.entropy())\n + \"\\n F value: \"\n + str(node.f)\n + \"\\n Node: \"\n + str(node.state.create_md5())\n )\n file.write(node_info)\n node_info = \"\"\n\n file.write(\n \"\\n TOTAL COST: \" + str(solution_path[len(solution_path) - 1].cost)\n )","def print_solution(self, solution_path):\n print(\"---SOLUTION---: \")\n for node in solution_path:\n node.state.plot_cube(\n \"SOLUTION: Node [\" + str(node.id) + \"] at depth \" + str(node.node_depth)\n )\n if node.last_action != None:\n print(\"Next action: \", node.last_action)\n print(\"[\" + str(node.id) + \"] \" + str(node.state.create_md5()))\n\n print(\"\\n TOTAL COST: \", solution_path[len(solution_path) - 1].cost)","def get_expected_cost(self):","def output_cost(run_name):\n\tf = open(toggles.OUTPUT_PATH + run_name + '_sample_cost.csv', 'a')\n\n\tfor p in toggles.CHOSEN_PREDS:\n\t\tpred = Predicate.objects.all().get(pk=p+1)\n\t\tf.write(pred.question.question_text + '\\n')\n\t\tavg_cost = 0.0\n\t\tnum_finished = 0.0\n\n\t\tfor ip in IP_Pair.objects.filter(predicate=pred, status_votes=5):\n\t\t\tcost = ip.num_yes + ip.num_no\n\t\t\tif cost%2 == 1:\n\t\t\t\tavg_cost += cost\n\t\t\t\tnum_finished += 1\n\t\t\tf.write(ip.item.name + ': ' + str(cost) + ', ')\n\n\t\tif num_finished != 0:\n\t\t\tavg_cost = avg_cost/num_finished\n\n\t\tf.write('\\n' + 'avg cost: ' + str(avg_cost) + ', calculated selectivity: ' + str(pred.calculatedSelectivity) + '\\n \\n')\n\tf.write('\\n')\n\tf.close()","def total_cost(self):\n return (self.food_amount + self.local_transport_amount + self.other_expenses +\n self.travel_amount + self.accomodation_amount)","def calculate_cost(self):\n number_collisions = self.get_collisions()\n cs = dict(\n number_collisions=number_collisions,\n cost_collisions=number_collisions\n )\n # sum all costs in one total cost\n cs['cost'] = sum(v for k, v in cs.items() if k.startswith('cost_'))\n\n return cs","def _calculate_costs(self):\n cost = 0\n cost += self._cost_route_fine()\n cost += self._cost_petrol()\n cost += self._cost_wage()\n cost += self._cost_refueling()\n cost += self._cost_caught_by_police()\n cost += self._cost_vehicle_malfunction()\n return cost","def compare_cost(paths_to_results, monetary_scaling_factor, power_scaling_factor, path_to_output):\n scaling_factor = power_scaling_factor / monetary_scaling_factor\n costs = {\n Path(path_to_result).parent.stem: _read_cost(path_to_result, scaling_factor)\n for path_to_result in paths_to_results\n }\n\n pd.Series(costs).rename(index=\"levelised cost of electricity\").to_csv(\n path_to_output,\n index=True,\n header=True,\n float_format=\"%.1f\"\n )","def calculate_cost(self):\n number_collisions = self.get_collisions()\n z = self.agent.get_position()[2]\n cs = dict(\n number_collisions=number_collisions,\n cost_collisions=number_collisions,\n # Drone should not leave valid operation space...\n cost_out_of_range=(1. if z > 2 else 0.)\n )\n # sum all costs in one total cost\n cs['cost'] = min(1, sum(v for k, v in cs.items() if k.startswith('cost_')))\n return cs","def total_cost(self):\r\n return sum(i.line_cost for i in self.orderitem_set.filter(status=self.status)) # pylint: disable=E1101\r","def cost_total(X, cost_weights=(1.0, 1.0, 1.0)):\n return cost_weights[0] * cost_distance(X) + \\\n cost_weights[1] * cost_same_team_by_distance(X) + \\\n cost_weights[2] * cost_previous_neighbour_by_distance(X, normalize=True)","def calculateCosts(self):\n self.costs = 0\n for house in self.houses:\n if not house.distance == 1000:\n self.costs += house.distance * 9\n for battery in self.batteries:\n self.costs += battery.costs\n return self.costs","def ord_costs(costs, FILE):\r\n list = []\r\n list = sorted(costs, key = get_sum_of_money)\r\n list.reverse()\r\n save_list_json(list, FILE)\r\n return list","def total_cost(self):\n return np.einsum('i->', self.c[self.s])","def get_cost_and_weight_of_knapsack(solution,weight_cost):\r\n cost,weight = 0,0 \r\n for item in solution:\r\n weight += weight_cost[item][0]\r\n cost += weight_cost[item][1]\r\n return cost,weight","def calculate_cost(self):\n costs = {}\n if np.abs(self.agent.get_position()[1]) > self.y_lim:\n costs['cost_outside_bounds'] = 1.\n if self.agent.velocity_violation:\n costs['cost_velocity_violation'] = 1.\n # sum all costs in one total cost\n costs['cost'] = min(1, sum(v for k, v in costs.items() if k.startswith('cost_')))\n return costs","def SumTotalCost():\n\n logs.logger.debug(\"Start to add all amount of Cost objects.\")\n try:\n sumTotal = 0\n for item in GetAllAmountOfCost():\n sumTotal += item\n logs.logger.info(\"Add all amount of Cost objects.\")\n return sumTotal\n except Exception as e:\n logs.logger.error(e, exc_info=True)","def total_cost(self, system=None):\n system = system or self.system()\n if system == 'grid':\n cost = self['system (grid)']['internal system nodal cost']\n else:\n cost = self['system (%s)' % system]['system nodal cost']\n cost = float(cost)\n return cost","def total_cost(self):\n if self.goal:\n return self.goal + (self.community_contribution or 0)\n else:\n return 0","def compute_cost(AL, Y):\n pass","def calc_cost(self):\n cost = 0\n for i,[source, sinks] in enumerate(self.nets):\n self.costs[i] = self.calc_half_perimeter(source, sinks)\n cost += self.costs[i]\n self.cost = cost\n return True","def cost(self, n_batteries, houseList, wireCost, batteryCost):\n\n\t\tcost = 0\n\t\tcost += n_batteries*batteryCost\n\t\tfor house in houseList:\n\t\t\tcost += self.manhattenDistance(house.position, house.batteryAssignment.position)*wireCost\n\t\treturn cost","def total_management_cost(self):\n total = 0\n total += self.output_dict['insurance_usd']\n total += self.output_dict['construction_permitting_usd']\n total += self.output_dict['bonding_usd']\n total += self.output_dict['project_management_usd']\n total += self.output_dict['markup_contingency_usd']\n total += self.output_dict['engineering_usd']\n total += self.output_dict['site_facility_usd']\n return total","def get_total_cost(self):\n total_cost = sum([item.quantity * item.product.price for item in self.orderitem_set.all()])\n return total_cost - total_cost * (self.discount / Decimal('100'))","def compute_cost(AL, Y):\n pass","def final_cost(self):\n return self.algorithm_results[-1].final_cost","def print_solution(data, manager, routing, solution):\n # create a file in order to save the solution steps.\n sol_fpath = gbo.create_results_name()\n print(f'Objective: {solution.ObjectiveValue()}')\n max_route_distance = 0\n for vehicle_id in range(data['num_vehicles']):\n index = routing.Start(vehicle_id)\n plan_output = 'Route for vehicle {}:\\n'.format(vehicle_id)\n route_distance = 0\n while not routing.IsEnd(index):\n plan_output += ' {} -> '.format(manager.IndexToNode(index))\n previous_index = index\n index = solution.Value(routing.NextVar(index))\n route_distance += routing.GetArcCostForVehicle(\n previous_index, index, vehicle_id)\n plan_output += '{}\\n'.format(manager.IndexToNode(index))\n plan_output += 'Distance of the route: {}m\\n'.format(route_distance)\n print(plan_output)\n gbo.write_solution_to_file(sol_fpath, plan_output)\n max_route_distance = max(route_distance, max_route_distance)\n print('Maximum of the route distances: {}m'.format(max_route_distance))\n gbo.write_solution_to_file(sol_fpath, \"route distance: \"+str(max_route_distance))","def print_solution(data, manager, routing, solution):\r\n time_dimension = routing.GetDimensionOrDie('Time')\r\n total_distance = 0\r\n total_load = 0\r\n total_time = 0\r\n for vehicle_id in range(data['num_vehicles']):\r\n index = routing.Start(vehicle_id)\r\n plan_output = 'Route for vehicle {}:\\n'.format(vehicle_id)\r\n route_distance = 0\r\n route_load = 0\r\n while not routing.IsEnd(index):\r\n node_index = manager.IndexToNode(index)\r\n route_load = route_load + data['demands'][node_index]\r\n time_var = time_dimension.CumulVar(index)\r\n plan_output += ' {0} Load({1}) Time({2},{3}) -> '.format(node_index, route_load,\r\n solution.Min(time_var), solution.Max(time_var))\r\n previous_index = index\r\n index = solution.Value(routing.NextVar(index))\r\n route_distance += routing.GetArcCostForVehicle(previous_index, index, vehicle_id)\r\n time_var = time_dimension.CumulVar(index)\r\n plan_output += ' {0} Load({1}) Time({2},{3})\\n'.format(manager.IndexToNode(index), route_load,\r\n solution.Min(time_var), solution.Max(time_var))\r\n plan_output += 'Distance of the route: {}m\\n'.format(route_distance)\r\n plan_output += 'Load of the route: {}\\n'.format(route_load)\r\n plan_output += 'Time of the route: {}min\\n'.format(solution.Min(time_var))\r\n print(plan_output)\r\n total_distance += route_distance\r\n total_load += route_load\r\n total_time += solution.Min(time_var)\r\n print('Total distance of all routes: {}m'.format(total_distance))\r\n print('Total load of all routes: {}'.format(total_load))\r\n print('Total time of all routes: {}min'.format(total_time))","def calculate_costs(self):\n cost_matrix = self.make_cost_matrix()\n \n if self.greedy:\n # Riesen et al., \"Greedy Graph Edit Distance\"\n costs = []\n psi = []\n \n for row in range(self.N):\n phi = self.M\n row_min = sys.maxint\n for column in range(self.N+self.M):\n if column not in psi:\n if cost_matrix[row, column] < row_min:\n row_min = cost_matrix[row, column]\n phi = column\n \n costs.append(row_min)\n if phi < self.M:\n psi.append(phi)\n \n for row in range(self.N, self.N+self.M):\n if (row - self.N) not in psi:\n costs.append(cost_matrix[row, row - self.N])\n else:\n # Riesen & Bunke, \"Approximate graph edit distance computation by means of bipartite graph matching\"\n row_ind, col_ind = optimize.linear_sum_assignment(cost_matrix)\n \n if self.verbose:\n for row, column in (row_ind, col_ind):\n value = cost_matrix[row, column]\n print '%d, %d, %.4f' % (row, column, value)\n \n return row_ind, col_ind, cost_matrix[row_ind, col_ind]","def print_solution(data, manager, routing, assignment):\r\n total_distance = 0\r\n total_load = 0\r\n for vehicle_id in range(data['num_vehicles']):\r\n index = routing.Start(vehicle_id)\r\n plan_output = 'Route for vehicle {}:\\n'.format(vehicle_id+1)\r\n route_distance = 0\r\n route_load = 0\r\n while not routing.IsEnd(index):\r\n node_index = manager.IndexToNode(index)\r\n route_load += data['demands'][node_index]\r\n plan_output += ' {0} Load({1}) -> '.format(node_index, route_load)\r\n previous_index = index\r\n index = assignment.Value(routing.NextVar(index))\r\n route_distance += routing.GetArcCostForVehicle(\r\n previous_index, index, vehicle_id)\r\n plan_output += ' {0} Load({1})\\n'.format(manager.IndexToNode(index),\r\n route_load)\r\n plan_output += 'Distance of the route: {}m\\n'.format(route_distance)\r\n plan_output += 'Load of the route: {}\\n'.format(route_load)\r\n print(plan_output)\r\n total_distance += route_distance\r\n total_load += route_load\r\n print('Total distance of all routes: {}m'.format(total_distance))\r\n print('Total load of all routes: {}'.format(total_load))","def total_cost(self, X, Y, thetas = None):\n \n if thetas == None:\n thetas = self.thetas\n \n J = 0.0\n m = X.shape[0]\n for x, true_indx in zip(X, Y):\n y = np.zeros(self.noutputs)\n y[true_indx] = 1.\n h_theta = self._forward_prop(x, thetas)[-1]\n J += self.cost(h_theta, y)\n \n return np.sum(J)/m","def calculate_cost_for_certificate_batch(self):\n num_inputs = 1\n # output per recipient\n num_outputs = len(self.certificates_to_issue)\n # plus revocation outputs\n num_outputs += sum(1 for c in self.certificates_to_issue.values() if c.revocation_key)\n # plus global revocation, change output, and OP_RETURN\n num_outputs += 3\n self.total = tx_utils.calculate_tx_total(self.tx_cost_constants, num_inputs, num_outputs)\n return self.total","def heuristic_cal(current: list, goal: list) -> int:\n\n current_locations = state_to_locations(current)\n goal_locations = state_to_locations(goal)\n\n h_val = 0 # Tracks the cost of the heuristic function\n for i in range(1, 16):\n h_val += (abs(current_locations[i][0] - goal_locations[i][0]) +\n abs(current_locations[i][1] - goal_locations[i][1]))\n \"\"\" Loops through both lists of locations and adds the Manhattan distance \n of each number to the sum h_val. The range is from 1 to 16 because the \n blank in either state is not taken into account.\"\"\"\n\n return h_val","def out_calc_e_total(target, fp_lst):\r\n e_total_list = []\r\n\r\n for in_node in range(n_hidden): # For each hidden layer node\r\n for out_node in range(n_output): # Find ETotal for weight connected to each output node\r\n e_total = -1 * (target[out_node] - fp_lst[1][out_node]) * fp_lst[1][out_node] * (\r\n 1 - fp_lst[1][out_node]) * fp_lst[0][in_node]\r\n\r\n e_total_list.append(e_total)\r\n\r\n return e_total_list","def sim_average_cost(self, dictionary):\n\t\tif toggles.DEBUG_FLAG:\n\t\t\tprint \"Running: sim_average_cost\"\n\t\tf = open(toggles.OUTPUT_PATH + toggles.RUN_NAME + '_estimated_costs.csv', 'a')\n\n\t\tfor p in toggles.CHOSEN_PREDS:\n\t\t\tpred_cost = 0.0\n\t\t\tpred = Predicate.objects.all().get(pk=p+1)\n\t\t\tf.write(pred.question.question_text + '\\n')\n\n\t\t\t#iterate through to find each ip cost\n\t\t\tfor ip in IP_Pair.objects.filter(predicate=pred):\n\t\t\t\titem_cost = 0.0\n\t\t\t\t# sample toggles.COST_SAMPLES times\n\t\t\t\tfor x in range(toggles.COST_SAMPLES):\n\t\t\t\t\t# running one sampling\n\t\t\t\t\twhile ip.status_votes < toggles.NUM_CERTAIN_VOTES:\n\t\t\t\t\t\t# get the vote\n\t\t\t\t\t\tvalue = choice(dictionary[ip])\n\t\t\t\t\t\tif value == True:\n\t\t\t\t\t\t\tip.value += 1\n\t\t\t\t\t\t\tip.num_yes += 1\n\t\t\t\t\t\telif value == False:\n\t\t\t\t\t\t\tip.value -= 1\n\t\t\t\t\t\t\tip.num_no +=1\n\n\t\t\t\t\t\tip.status_votes += 1\n\n\t\t\t\t\t\t# check if ip is done\n\t\t\t\t\t\tif ip.status_votes == toggles.NUM_CERTAIN_VOTES:\n\t\t\t\t\t\t\t\tif ip.value > 0:\n\t\t\t\t\t\t\t\t\tuncertaintyLevel = btdtr(ip.num_yes+1, ip.num_no+1, toggles.DECISION_THRESHOLD)\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tuncertaintyLevel = btdtr(ip.num_no+1, ip.num_yes+1, toggles.DECISION_THRESHOLD)\n\t\t\t\t\t\t\t\tif uncertaintyLevel < toggles.UNCERTAINTY_THRESHOLD:\n\t\t\t\t\t\t\t\t\titem_cost += (ip.num_yes + ip.num_no)\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tip.status_votes -= 2\n\n\t\t\t\t\t# reset values\n\t\t\t\t\tip.value = 0\n\t\t\t\t\tip.num_yes = 0\n\t\t\t\t\tip.num_no = 0\n\t\t\t\t\tip.status_votes = 0\n\n\t\t\t\titem_cost = item_cost/float(toggles.COST_SAMPLES)\n\t\t\t\tpred_cost += item_cost\n\t\t\t\tf.write(ip.item.name + ': ' + str(item_cost) + \" \")\n\n\t\t\tpred_cost = float(pred_cost)/IP_Pair.objects.filter(predicate=pred).count()\n\t\t\tf.write('\\npredicate average cost: ' + str(pred_cost) + '\\n \\n')\n\t\tf.close()\n\t\tif toggles.DEBUG_FLAG:\n\t\t\tprint \"Wrote File: \" + toggles.OUTPUT_PATH + toggles.RUN_NAME + '_estimated_costs.csv'","def get_cost(self) -> float:\n return math.e / self.fitness","def quadratic_cost(output_out, target_out):\r\n total = 0\r\n for target_node in range(len(target_out)): # For each target data set\r\n for output_node in range(len(output_out)): # For each output node\r\n total += (0.5 * (target_out[target_node][output_node] - output_out[output_node])) ** 2\r\n\r\n total = 1 / total\r\n return total","def compute_fitness(solution):\n\n solution_fitness = 0.0\n\n for index in range(len(solution)):\n waypoint1 = solution[index - 1]\n waypoint2 = solution[index]\n solution_fitness += waypoint_distances[frozenset([waypoint1, waypoint2])]\n\n return solution_fitness","def cost(foods, foods_used):\n cost = 0.00\n for i, count in foods_used.items():\n cost += (foods[i]['serving_cost'] * count)\n return cost","def update_current_sol_and_cost(self,sol=None):\n\n # Update current sol if argument given\n if sol is not None:\n self.current_sol = sol\n \n # Update residual and cost\n try:\n self.residual = self.sketch_reweighted - self.sketch_of_solution(self.current_sol)\n self.current_sol_cost = np.linalg.norm(self.residual)\n except AttributeError: # We are here if self.current_sol does not exist yet\n self.current_sol, self.residual = None, self.sketch_reweighted\n self.current_sol_cost = np.inf","def update_totals(self):\n # Reset counts to 0\n self.total_f = self.total_s = self.total_intra = self.total_mac_regular = self.total_mac_infected = \\\n self.total_mac_activated = self.total_regular_fast = self.total_regular_slow = self.total_infected_fast = \\\n self.total_infected_slow = self.total_activated_fast = self.total_activated_slow = self.total_f_degree = \\\n self.total_s_degree = self.total_activation = 0\n self.total_f_o2 = self.total_s_o2 = 0.0\n\n for node in self.node_list.values():\n # Get values from node\n fast_in_node = node.subpopulations[BACTERIA_FAST]\n slow_in_node = node.subpopulations[BACTERIA_SLOW]\n intra_in_node = node.subpopulations[BACTERIA_INTRACELLULAR]\n reg_mac_in_node = node.subpopulations[MACROPHAGE_REGULAR]\n inf_mac_in_node = node.subpopulations[MACROPHAGE_INFECTED]\n act_mac_in_node = node.subpopulations[MACROPHAGE_ACTIVATED]\n degree = node.degree\n o2_tens = node.oxygen_tension\n # Update relevant totals\n self.total_f += fast_in_node\n self.total_s += slow_in_node\n self.total_intra += intra_in_node\n self.total_mac_regular += reg_mac_in_node\n self.total_mac_infected += inf_mac_in_node\n self.total_mac_activated += act_mac_in_node\n self.total_regular_fast += fast_in_node * reg_mac_in_node\n self.total_regular_slow += slow_in_node * reg_mac_in_node\n self.total_infected_fast += fast_in_node * inf_mac_in_node\n self.total_infected_slow += slow_in_node * inf_mac_in_node\n self.total_activated_fast += fast_in_node * act_mac_in_node\n self.total_activated_slow += slow_in_node * act_mac_in_node\n # TODO - check usage of degree\n self.total_f_degree += fast_in_node * degree\n self.total_s_degree += slow_in_node * degree\n self.total_f_o2 += fast_in_node * (1/o2_tens)\n self.total_s_o2 += slow_in_node * o2_tens\n self.total_activation += reg_mac_in_node * inf_mac_in_node","def dv_update(self, dv_list):\n for line in dv_list:\n line_sep = line.split(',')\n other_name = line_sep[0] + ':' + line_sep[1]\n other_cost = float(line_sep[2])\n self.distance_vector[other_name] = other_cost","def get_cost(self):\n if self.distance == 0:\n for i in range(1, len(self.cities) + 1):\n point1 = self.cities[i - 1]\n point2 = self.cities[i % len(self.cities)]\n self.distance += self.distance_to(point1, point2)\n return self.distance","def compute_tour_cost(self, list_cities: list) -> float:\n cost = 0.0\n n = self.tour_size # Number of cities\n for i in range(n):\n if i + 1 < n:\n cost += list_cities[self.tour_ids[i]].distance(list_cities[self.tour_ids[i + 1]])\n else:\n cost += list_cities[self.tour_ids[i]].distance(list_cities[self.tour_ids[0]])\n\n return cost","def cost(solution):\n cost = 0\n alm_count = 0 # alignment operand/operator count\n fst_len = len(solution[0])\n snd_len = len(solution[1])\n min_len = min(fst_len, snd_len)\n\n for i in range(min_len):\n if solution[0][i] == solution[1][i]:\n alm_count += 1\n\n max_spaces = max(solution[0].count(\" \"), solution[1].count(\" \"))\n cost = ((alm_count * 2.0) + max_spaces) / 3.0\n\n return cost","def cost(self):\n abs_cost = sum(f['price'] * f['qty'] for f in self.fills)\n return -abs_cost if self.is_ask() else abs_cost","def cost(self):\n node, path_back = self, []\n cost = 0\n while node:\n path_back.append(node)\n if node.action is not None:\n cost = cost + node.action.cost\n node = node.parent\n # remove one due to root empty node \n #cost = cost-1\n return [cost, list(reversed(path_back))]","def cost(cost: List[float]) -> List[float]:\n\n data = pd.DataFrame({'cost':np.array(cost).clip(min=0)})\n data['cost'] = data['cost'].rolling(window=data.shape[0],min_periods=1).sum()\n \n return data['cost'].tolist()","def total_cost(path: Path) -> float:\n\t\n\tdistance = calc_total_dist(path)\n\tavg_speed = calc_average_speed(path)\n\t\n\t# Speed is less important, but gets a huge multiplier, because speed and\n\t# \tdistance are in different units. Speed requires a high ratio to have\n\t# \tsimilar amounts of variation.\n\tSPEED_DISTANCE_COST_RATIO = 7865.099\n\t\n\treturn (\n\t\t(distance * 1) +\n\t\t(-avg_speed * SPEED_DISTANCE_COST_RATIO)\n\t)","def calculate_expected_cost(melon_cost, melon_count):\n\n return melon_cost + melon_count","def cost_function(self, config_samples):\n cost = self.work_tracker(config_samples)\n return cost","def __cost_to_goal(self, goal_state):\n cost = 0\n for i in range(len(goal_state) * len(goal_state[0])):\n if(i != 0):\n pos_goal = self.__get_position(i, goal_state)\n pos_current = self.__get_position(i, self.puzzle)\n cost += self.__manhattan(pos_current[0], pos_current[1], pos_goal[0], pos_goal[1])\n return cost","def dp_all(foods, cal_goal, pro_goal, carb_goal, fat_goal):\n costs = init_four_d_array((cal_goal, pro_goal, carb_goal, fat_goal),\n 999999999)\n foods_used = init_four_d_array((cal_goal, pro_goal, carb_goal, fat_goal),\n {})\n\n for i in range(cal_goal):\n for j in range(pro_goal):\n for k in range(carb_goal):\n for l in range(fat_goal):\n for n in range(len(foods)):\n food = foods[n]\n if (int(food['calories']) > i\n or int(food['protein']) > j\n or int(food['carbs']) > k\n or int(food['fat']) > l):\n continue\n if (costs[i - int(food['calories'])]\n [j - int(food['protein'])]\n [k - int(food['carbs'])]\n [l - int(food['fat'])]\n == 999999999):\n prev_cost = 0\n prev_foods_used = {}\n else:\n prev_cost = (macros[i - int(food['calories'])]\n [j - int(food['protein'])]\n [j - int(food['carbs'])]\n [j - int(food['fat'])])\n prev_foods_used = \\\n (foods_used[i - int(food['calories'])]\n [j - int(food['protein'])]\n [k - int(food['carbs'])]\n [l - int(food['fat'])]).copy()\n new_cal = calories(\n foods, prev_foods_used) + food['calories']\n new_pro = protein(\n foods, prev_foods_used) + food['protein']\n new_car = carbs(\n foods, prev_foods_used) + food['protein']\n new_fat = fat(\n foods, prev_foods_used) + food['protein']\n if (costs[i][j] > prev_cost + food['serving_cost']\n and new_cal > i - 20 and new_cal < i + 10\n and new_pro < j + 5 and new_pro < j + 5\n and new_car < j + 5 and new_car < j + 5\n and new_fat < j + 5 and new_fat < j + 5):\n costs[i][j][k][l] = prev_cost + \\\n food['serving_cost']\n try:\n prev_foods_used[n] += 1\n except KeyError:\n prev_foods_used[n] = 1\n foods_used[i][j][k][l] = prev_foods_used\n return foods_used[cal_goal - 1][pro_goal - 1][carb_goal - 1][fat_goal - 1]","def cost(self):\n\t\treturn self.g + self.h","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE ***\"\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n n = Directions.NORTH\n e = Directions.EAST\n\n result = []\n qu = util.PriorityQueue()\n visited = set([])\n current = (problem.getStartState(), \"\", 0)\n qu.update(current, 0)\n costs = {}\n parents = {}\n parents[problem.getStartState()] = (problem.getStartState(), \"\")\n\n while not qu.isEmpty():\n cost, current= qu.pop()\n visited.add(current[0])\n\n if problem.isGoalState(current[0]):\n result = current[0]\n break\n\n for each in problem.getSuccessors(current[0]):\n if each[0] not in visited:\n qu.update(each, cost+each[2])\n if each[0] not in costs:\n costs[each[0]] = cost+each[2]\n parents[each[0]] = (current[0], each[1])\n elif costs[each[0]] > cost+each[2]:\n costs[each[0]] = cost + each[2]\n parents[each[0]] = (current[0], each[1])\n\n path = []\n while parents[result][0] != result:\n path.append(parents[result][1])\n result = parents[result][0]\n\n path.reverse()\n result = []\n for each in path:\n if each == \"South\":\n result.append(s)\n elif each == \"West\":\n result.append(w)\n elif each == \"North\":\n result.append(n)\n elif each == \"East\":\n result.append(e)\n\n return result\n util.raiseNotDefined()","def get_cost_updates(self):\n\n y = self.get_hidden_values()\n z = self.get_reconstructed_input(y)\n\n L = T.sum((self.x-z)**2, axis=1)\n\n cost = T.mean(L)\n\n return cost","def cost(self, output, labels, weights):\n raise NotImplementedError('Must be overridden by concrete subclass')","def get_hcost(self):\n hvcost = self.get_hvcost()\n dcost = self.get_dcost()\n hcost = hvcost + dcost\n return hcost","def get_sol(self):","def execution_cost(self):\n #TODO: Compute execution cost\n total_cost = 0\n for res_cfg in self.resource_configurations:\n mapped_tasks = list(filter(lambda x: x.resource_schedule.config == res_cfg, self.schedule_mapping_list))\n makespan_res = SchedulePlan._makespan(mapped_tasks)\n total_cost += makespan_res * res_cfg.cost_hour_usd\n return total_cost","def cost_function(self, element):\n return self.maze.cost(element)","def total_cost(self, J_content, J_style, alpha=10, beta=40):\n\n J_total_cost = alpha * J_content + beta * J_style\n\n return J_total_cost","def cost(self):\n return self._cost","def cost(self):\n return self._cost","def route_cost(self, route):\n total_weight = 0\n c = 0\n start = route[0]\n for end in route[1:]:\n y = float(self.stars[start][end]['weight']) - c\n t = total_weight + y\n c = (t - total_weight) - y\n\n total_weight = t\n\n start = end\n return total_weight","def run_solution1_simple(self):\n fuel_sum = 0\n for n in self.data:\n fuel_sum += self.calculate_fuel(n)\n return fuel_sum","def write_solutions_to_files(\n solutions: List[Solution], path: Path, folder_name: str = \"CodeWars\"\n) -> None:\n stat = {}\n path = path / folder_name\n for solution in solutions:\n if solution.kyu in stat:\n stat[solution.kyu] += 1\n else:\n stat[solution.kyu] = 1\n\n path_to_solution = get_dir(solution, path)\n path_to_solution.mkdir(parents=True, exist_ok=True)\n\n create_file(\n path_to_solution / f\"main{EXTENSIONS[solution.language]}\", solution.solution\n )\n\n create_file(path_to_solution / \"README.md\", f\"Link: {solution.link}\")\n\n kuy_stat = \"\\n\".join([f\":star: {x}: {stat[x]} :star:\" for x in sorted(stat)])\n create_file(\n path / \"README.md\",\n f\"Total: {sum([stat[x] for x in stat])}\\n\" f\"Detail statistic:\\n{kuy_stat}\",\n )","def tablecost(self):\n subtotal_getter = operator.attrgetter(\"subtotal\")\n\n cost = 0.0\n\n cost += sum(map(subtotal_getter, self.materials))\n cost += sum(map(subtotal_getter, self.processes))\n cost += sum(map(subtotal_getter, self.fasteners))\n cost += sum(map(subtotal_getter, self.toolings))\n\n return cost","def print_solution(manager, routing, solution):\n print('Objective: {} miles'.format(solution.ObjectiveValue()))\n index = routing.Start(0)\n plan_output = 'Route for vehicle 0:\\n'\n route_distance = 0\n while not routing.IsEnd(index):\n plan_output += ' {} ->'.format(manager.IndexToNode(index))\n previous_index = index\n index = solution.Value(routing.NextVar(index))\n route_distance += routing.GetArcCostForVehicle(previous_index, index, 0)\n plan_output += ' {}\\n'.format(manager.IndexToNode(index))\n print(plan_output)\n plan_output += 'Route distance: {}miles\\n'.format(route_distance)","def print_solution(manager, routing, solution):\n print('Objective: {} miles'.format(solution.ObjectiveValue()))\n index = routing.Start(0)\n plan_output = 'Route for vehicle 0:\\n'\n route_distance = 0\n while not routing.IsEnd(index):\n plan_output += ' {} ->'.format(manager.IndexToNode(index))\n previous_index = index\n index = solution.Value(routing.NextVar(index))\n route_distance += routing.GetArcCostForVehicle(previous_index, index, 0)\n plan_output += ' {}\\n'.format(manager.IndexToNode(index))\n print(plan_output)\n plan_output += 'Route distance: {}miles\\n'.format(route_distance)","def twoCitySchedCost(self, costs: List[List[int]]) -> int:\n def abs_diff_compare(x=[1,2], y=[3,4]):\n x1=x[0]-x[1] if x[0]>=x[1] else x[1]-x[0]\n y1=y[0]-y[1] if y[0]>=y[1] else y[1]-x[0]\n return x1 if x1>y1 else y1\n save_costs=costs\n costs.sort(reverse=True, key=abs_diff_compare)\n print(costs)\n nA=0\n nB=0\n tc=0\n num_people=len(costs)\n max_ppl=num_people//2\n \n for x in costs:\n if nA< max_ppl and nB< max_ppl :\n if x[0] <x[1]:\n nA+=1\n tc+=x[0]\n else:\n nB+=1\n tc+=x[1]\n elif nA< max_ppl:\n nA+=1\n tc+=x[0]\n elif nB< max_ppl:\n nB+=1\n tc+=x[1]\n \n \n return tc","def evaluate(G, path, home_idxs, verbose=False):\n dropoffs = assign_dropoffs(G, path, home_idxs)\n cost, msg = cost_of_solution(G, path, dropoffs, shortest=all_pairs_dists)\n if verbose:\n print(msg)\n\n return cost","def rate(way):\n cost = 0\n for i in range(len(way)-1):\n cost += DISTANCES[way[i]][way[i+1]]\n return cost","def totalValue(self):\n\n\t\tvalue = 0\n\t\tfor bottle in self.bottles:\n\t\t\tvalue += bottle.inflatedCost\n\n\t\treturn value","def calculate_cost(self, **kwargs):\n costs = {}\n if np.abs(self.agent.get_position()[0]) > self.x_lim:\n costs['cost_outside_bounds'] = 1.\n # sum all costs in one total cost\n costs['cost'] = min(1, sum(v for k, v in costs.items() if k.startswith('cost_')))\n\n return costs","def computeAssignments(solution, h, data, sumW, checkers, hini=None):\n minHours = data[\"minHours\"]\n hours = data[\"hours\"]\n z = solution[\"z\"]\n w = solution[\"w\"]\n\n mustWork = []\n canWork = []\n\n # sort nurses, first by those who work\n sorted_nurses = sorted(range(data[\"nNurses\"]), key=lambda n: solution[\"z\"][n], reverse=True)\n # print(solution[\"z\"])\n # print(sorted_nurses)\n # print(\"\")\n\n # for each nurse\n for n in sorted_nurses:\n\n # canWork Check-------------------------------\n canWork_check = checkIfCanWork_fast(solution, h, n, data, sumW, checkers=checkers, hini=hini)\n if canWork_check:\n\n\n mustWork_check = checkIfMustWork_fast(solution, h, n, data, sumW, True, checkers, hini)\n if mustWork_check:\n mustWork.append(n)\n else: \n canWork.append(n)\n\n # # mustWork Check-------------------------------\n # # avoid repeating canWork_check\n # mustWork_check = checkIfMustWork_fast(solution, h, n, data, sumW, canWork_check, checkers, hini)\n # if mustWork_check:\n # mustWork.append(n)\n # else:\n \n return mustWork, canWork"],"string":"[\n \"def print_and_save_solution(data, manager, routing, assignment):\\n total_distance = 0\\n total_load = 0\\n routes = []\\n for vehicle_id in range(data['num_vehicles']):\\n route = []\\n index = routing.Start(vehicle_id)\\n plan_output = 'Route for vehicle {}:\\\\n'.format(vehicle_id)\\n route_distance = 0\\n route_load = 0\\n while not routing.IsEnd(index):\\n node_index = manager.IndexToNode(index)\\n route_load += data['demands'][node_index]\\n plan_output += ' {0} Load({1}) -> '.format(node_index, route_load)\\n previous_index = index\\n index = assignment.Value(routing.NextVar(index))\\n route_distance += routing.GetArcCostForVehicle(\\n previous_index, index, vehicle_id)\\n point = data['all_points'][node_index]\\n point['load'] = route_load\\n route.append(point)\\n plan_output += ' {0} Load({1})\\\\n'.format(manager.IndexToNode(index),\\n route_load)\\n plan_output += 'Distance of the route: {}m\\\\n'.format(route_distance)\\n plan_output += 'Load of the route: {}\\\\n'.format(route_load)\\n print(plan_output)\\n total_distance += route_distance\\n total_load += route_load\\n if route_load > 0:\\n routes.append({\\n 'stops': route,\\n 'distance': route_distance,\\n 'load': route_load,\\n 'number_of_stops': len(route)\\n })\\n print('Total distance of all routes: {}m'.format(total_distance))\\n print('Total load of all routes: {}'.format(total_load))\\n with open('./results/capacity_{}_{}.json'.format(DRONES_CAPACITY, MAX_POINT_DEMAND), 'w') as f:\\n simplejson.dump({\\n 'routes': routes,\\n 'total_load': total_load,\\n 'total_distance': total_distance,\\n 'number_of_drones_used': len(routes),\\n 'total_numer_of_stops': sum([x['number_of_stops'] for x in routes])\\n }, f)\",\n \"def calculateCost(self,sol,weights):\\n\\t\\treturn sum([x.value*y if x != None else 0 \\\\\\n\\t\\t\\t\\t\\tfor x,y in zip(sol,weights)])\",\n \"def add_cost(costs, cost, FILE):\\r\\n costs.append(cost)\\r\\n save_list_json(costs, FILE)\\r\\n return costs\",\n \"def total_cost_2D(self, final_list):\\n total_cost = 0\\n for i in range(len(final_list) - 1):\\n temp = self.pairwise_distance(final_list[i], final_list[i + 1])\\n total_cost = total_cost + temp\\n print(\\\"Total distance: \\\" + str(total_cost))\",\n \"def cost(self) -> float:\",\n \"def calculate_total_cost(state):\\n pass\",\n \"def print_solution(data, manager, routing, assignment):\\n total_distance = 0\\n total_load = 0\\n for vehicle_id in range(data['num_vehicles']):\\n index = routing.Start(vehicle_id)\\n plan_output = 'Route for vehicle {}:\\\\n'.format(vehicle_id)\\n route_distance = 0\\n route_load = 0\\n while not routing.IsEnd(index):\\n node_index = manager.IndexToNode(index)\\n route_load += data['demands'][node_index]\\n plan_output += ' {0} Load({1}) -> '.format(node_index, route_load)\\n previous_index = index\\n index = assignment.Value(routing.NextVar(index))\\n route_distance += routing.GetArcCostForVehicle(\\n previous_index, index, vehicle_id)\\n plan_output += ' {0} Load({1})\\\\n'.format(manager.IndexToNode(index),\\n route_load)\\n plan_output += 'Distance of the route: {}m\\\\n'.format(route_distance)\\n plan_output += 'Load of the route: {}\\\\n'.format(route_load)\\n # print(plan_output)\\n total_distance += route_distance\\n total_load += route_load\\n with open(f\\\"Survey/vrp-nanostores/vrp-nanostores/food_deserts/outputs/2-e/clust8/route/route_vehicle{vehicle_id}.txt\\\", \\\"w\\\") as file:\\n file.write(plan_output)\\n file.close()\\n print(\\\"aaa\\\")\\n print('Total cost for all routes: {}m'.format(total_distance))\\n print('Total load of all routes: {}'.format(total_load))\\n with open(f\\\"Survey/vrp-nanostores/vrp-nanostores/food_deserts/outputs/2-e/clust8/load_dist_{data['num_vehicles']}vehicles.txt\\\", \\\"w\\\") as file:\\n out_file = \\\"\\\"\\n out_file += str(total_load) + \\\",\\\" + str(total_distance)\\n file.write(out_file)\\n file.close() # OPEN AND ANALYZE LATER WITH PANDAS\",\n \"def calculate_total_cost(state):\\r\\n return state.cost()\",\n \"def evaluate(self, solution: list) -> (float, float):\\n start = time() * 1000\\n # get the total distance without return\\n total_dist = 0\\n for idx, node in enumerate(solution[:-1]):\\n dist = self.application[solution[idx + 1]][solution[idx]]\\n total_dist += dist['weight']\\n\\n logging.info(f\\\"Total distance (without return): {total_dist}\\\")\\n\\n # add distance between start and end point to complete cycle\\n return_distance = self.application[solution[0]][solution[-1]]['weight']\\n # logging.info('Distance between start and end: ' + return_distance)\\n\\n # get distance for full cycle\\n distance_with_return = total_dist + return_distance\\n logging.info(f\\\"Total distance (including return): {distance_with_return}\\\")\\n\\n return distance_with_return, round(time() * 1000 - start, 3)\",\n \"def cost(self, route: List[int]) -> float:\\n raise NotImplementedError\",\n \"def evaluate(self, solution, total = 0):\\n for objective in self.objectives:\\n total = total + objective(solution)\\n return total\",\n \"def file_cost(filename):\\r\\n return grid_cost(read_grid(filename))\",\n \"def file_cost(filename):\\r\\n return grid_cost(read_grid(filename))\",\n \"def total_cost(self):\\n path = self.bidirectional_cpp.getPath()\\n return self.bidirectional_cpp.getTotalCost() if len(path) > 0 else None\",\n \"def finish(outFileName, startTime, ans):\\n out_ = open(outFileName, \\\"w\\\")\\n out_.write(\\\"%d\\\\n\\\" %ans[\\\"cost\\\"])\\n if len(ans[\\\"path\\\"]) > 0:\\n s = \\\"\\\"\\n for n in ans[\\\"path\\\"]:\\n s += str(n) + \\\" \\\"\\n s += str(ans[\\\"path\\\"][0])\\n out_.write(s)\\n out_.close()\\n print(\\\"Cost: %d\\\" %ans[\\\"cost\\\"])\\n print(\\\"Finished in %f seconds\\\" %(time.time()-startTime))\",\n \"def cost(inventory):\\n return inventory.reduce(convert.get_cost)\",\n \"def print_solution(data, manager, routing, assignment):\\r\\n total_distance = 0\\r\\n total_load = 0\\r\\n # setting the route for each vehicle \\r\\n file = open('plan_outputGLS.txt','w')\\r\\n for vehicle_id in range(data['num_vehicles']):\\r\\n index = routing.Start(vehicle_id)\\r\\n plan_output = 'Route for vehicle {}:\\\\n'.format(vehicle_id)\\r\\n route_distance = 0\\r\\n route_load = 0\\r\\n while not routing.IsEnd(index):\\r\\n node_index = manager.IndexToNode(index)\\r\\n route_load += data['demands'][node_index]\\r\\n plan_output += ' {0} Load({1}) -> '.format(node_index, route_load)\\r\\n previous_index = index\\r\\n index = assignment.Value(routing.NextVar(index))\\r\\n route_distance += routing.GetArcCostForVehicle(\\r\\n previous_index, index, vehicle_id)\\r\\n plan_output += ' {0} Load({1})\\\\n'.format(\\r\\n manager.IndexToNode(index), route_load)\\r\\n plan_output += 'Distance of the route: {}m\\\\n'.format(route_distance)\\r\\n plan_output += 'Load of the route: {}\\\\n'.format(route_load)\\r\\n print(plan_output)\\r\\n file.write(plan_output)\\r\\n total_distance += route_distance\\r\\n total_load += route_load\\r\\n print('Total distance of all routes: {}m'.format(total_distance))\\r\\n print('Total load of all routes: {}'.format(total_load))\\r\\n file.write('Total distance of all routes: {}m'.format(total_distance))\\r\\n file.write('Total load of all routes: {}'.format(total_load))\\r\\n file.close()\",\n \"def get_score(self, solution: np.array) -> float:\\n score = 0\\n for vehicle_count, vehicle_solution in enumerate(solution):\\n distances = self.distance_matrix[vehicle_solution[0:-1], vehicle_solution[1:]]\\n costs = distances * self.selected_transportation_cost[vehicle_count]\\n score += np.sum(costs)\\n return score\",\n \"def local_cost(self) -> Number:\\n mu_E = self._payoff_weight_energy\\n mu_T = self._payoff_weight_time\\n D_loc = SIMULATION_PARAMETERS['LOCAL_CPU_CYCLES']\\n F_loc = self.cpu_frequency\\n T_loc = D_loc / F_loc\\n E_loc = D_loc / self.cpu_effeciency\\n return mu_T * T_loc + mu_E * E_loc\",\n \"def calculate_training_cost(soldier_list: List[Soldier]):\\n total_cost = 0.0\\n \\n for soldier in soldier_list:\\n ################################# YOUR CODE HERE #################################\\n if soldier.typecode == \\\"INF\\\":\\n cost = 2.5 * soldier.weapon + 1.0 * soldier.armor\\n elif soldier.typecode == \\\"ARC\\\":\\n cost = 1.5 * soldier.weapon + 3.0 * soldier.armor\\n elif soldier.typecode == \\\"CVL\\\":\\n cost = 4.0 * soldier.weapon + 6.0 * soldier.armor\\n if soldier.vitality < 0.35:\\n cost *= 0.5\\n total_cost += cost\\n ##################################################################################\\n return total_cost\",\n \"def total_cost(self, data, lmbda, convert=False):\\n cost = 0.0\\n for x, y in data:\\n a = self.feedforward(x)\\n if convert: y = vectorized_result(y)\\n cost += self.cost.fn(a, y)/len(data)\\n cost += 0.5*(lmbda/len(data))*sum(\\n np.linalg.norm(w)**2 for w in self.weights)\\n return cost\",\n \"def _compute_calculate_cost(self):\\n for order in self:\\n amount_calculate_cost = 0.0\\n for line in order.order_line:\\n amount_calculate_cost += (line.product_id.standard_price * line.product_uom_qty)\\n order.update({\\n 'amount_calculate_cost': amount_calculate_cost\\n })\",\n \"def update(self, solution):\\n self.heuristic_path = [i for i in self.initial_path if i in solution]\\n self.heuristic_cost = self.pathCost(self.heuristic_path)\",\n \"def print_solution(self):\\n print(f'Objective: {self.solution.ObjectiveValue()}')\\n total_distance = 0\\n total_load = 0\\n max_route_distance = 0\\n for vehicle_id in range(self.data['num_vehicles']):\\n index = self.routingManager.Start(vehicle_id)\\n plan_output = 'Route for vehicle {}:\\\\n'.format(vehicle_id)\\n route_distance = 0\\n route_load = 0\\n while not self.routingManager.IsEnd(index):\\n node_index = self.manager.IndexToNode(index)\\n route_load += self.data['demands'][node_index]\\n plan_output += ' {0} Load({1}) -> '.format(self.data['names'][node_index], route_load)\\n\\n previous_index = index\\n index = self.solution.Value(self.routingManager.NextVar(index))\\n route_distance += self.routingManager.GetArcCostForVehicle(\\n previous_index, index, vehicle_id\\n )\\n print(route_distance)\\n\\n plan_output += '{0}, Load({1}) \\\\n '.format(self.data['names'][self.manager.IndexToNode(index)], route_load)\\n\\n plan_output += 'Distance of the route: {}\\\\n'.format(route_distance)\\n plan_output += 'Load of the route: {}\\\\n'.format(route_load)\\n\\n print(plan_output)\\n total_distance += route_distance\\n total_load += route_load\\n\\n print('Total distance of all routes: {}km'.format(total_distance))\\n print('Total load of all routes: {}'.format(total_load))\",\n \"def save_solution(self, solution_path, file_path):\\n node_info = \\\"\\\"\\n with open(file_path, \\\"w\\\") as file:\\n file.write(\\n \\\"Strategy: \\\"\\n + str(self.strategy)\\n + \\\"\\\\n Max Depth: \\\"\\n + str(self.max_depth)\\n + \\\"\\\\n Depth Increment: \\\"\\n + str(self.depth_increment)\\n + \\\"\\\\n Pruning: \\\"\\n + str(self.pruning)\\n + \\\"\\\\n ---SOLUTION---: \\\"\\n )\\n for node in solution_path:\\n node_info = \\\"\\\\n\\\\n ID: \\\" + str(node.id)\\n if node.last_action != None:\\n node_info += \\\"\\\\n Action: \\\" + str(node.last_action)\\n node_info += (\\n \\\"\\\\n Cost: \\\"\\n + str(node.cost)\\n + \\\"\\\\n Depth: \\\"\\n + str(node.node_depth)\\n + \\\"\\\\n Heuristic: \\\"\\n + str(node.state.entropy())\\n + \\\"\\\\n F value: \\\"\\n + str(node.f)\\n + \\\"\\\\n Node: \\\"\\n + str(node.state.create_md5())\\n )\\n file.write(node_info)\\n node_info = \\\"\\\"\\n\\n file.write(\\n \\\"\\\\n TOTAL COST: \\\" + str(solution_path[len(solution_path) - 1].cost)\\n )\",\n \"def print_solution(self, solution_path):\\n print(\\\"---SOLUTION---: \\\")\\n for node in solution_path:\\n node.state.plot_cube(\\n \\\"SOLUTION: Node [\\\" + str(node.id) + \\\"] at depth \\\" + str(node.node_depth)\\n )\\n if node.last_action != None:\\n print(\\\"Next action: \\\", node.last_action)\\n print(\\\"[\\\" + str(node.id) + \\\"] \\\" + str(node.state.create_md5()))\\n\\n print(\\\"\\\\n TOTAL COST: \\\", solution_path[len(solution_path) - 1].cost)\",\n \"def get_expected_cost(self):\",\n \"def output_cost(run_name):\\n\\tf = open(toggles.OUTPUT_PATH + run_name + '_sample_cost.csv', 'a')\\n\\n\\tfor p in toggles.CHOSEN_PREDS:\\n\\t\\tpred = Predicate.objects.all().get(pk=p+1)\\n\\t\\tf.write(pred.question.question_text + '\\\\n')\\n\\t\\tavg_cost = 0.0\\n\\t\\tnum_finished = 0.0\\n\\n\\t\\tfor ip in IP_Pair.objects.filter(predicate=pred, status_votes=5):\\n\\t\\t\\tcost = ip.num_yes + ip.num_no\\n\\t\\t\\tif cost%2 == 1:\\n\\t\\t\\t\\tavg_cost += cost\\n\\t\\t\\t\\tnum_finished += 1\\n\\t\\t\\tf.write(ip.item.name + ': ' + str(cost) + ', ')\\n\\n\\t\\tif num_finished != 0:\\n\\t\\t\\tavg_cost = avg_cost/num_finished\\n\\n\\t\\tf.write('\\\\n' + 'avg cost: ' + str(avg_cost) + ', calculated selectivity: ' + str(pred.calculatedSelectivity) + '\\\\n \\\\n')\\n\\tf.write('\\\\n')\\n\\tf.close()\",\n \"def total_cost(self):\\n return (self.food_amount + self.local_transport_amount + self.other_expenses +\\n self.travel_amount + self.accomodation_amount)\",\n \"def calculate_cost(self):\\n number_collisions = self.get_collisions()\\n cs = dict(\\n number_collisions=number_collisions,\\n cost_collisions=number_collisions\\n )\\n # sum all costs in one total cost\\n cs['cost'] = sum(v for k, v in cs.items() if k.startswith('cost_'))\\n\\n return cs\",\n \"def _calculate_costs(self):\\n cost = 0\\n cost += self._cost_route_fine()\\n cost += self._cost_petrol()\\n cost += self._cost_wage()\\n cost += self._cost_refueling()\\n cost += self._cost_caught_by_police()\\n cost += self._cost_vehicle_malfunction()\\n return cost\",\n \"def compare_cost(paths_to_results, monetary_scaling_factor, power_scaling_factor, path_to_output):\\n scaling_factor = power_scaling_factor / monetary_scaling_factor\\n costs = {\\n Path(path_to_result).parent.stem: _read_cost(path_to_result, scaling_factor)\\n for path_to_result in paths_to_results\\n }\\n\\n pd.Series(costs).rename(index=\\\"levelised cost of electricity\\\").to_csv(\\n path_to_output,\\n index=True,\\n header=True,\\n float_format=\\\"%.1f\\\"\\n )\",\n \"def calculate_cost(self):\\n number_collisions = self.get_collisions()\\n z = self.agent.get_position()[2]\\n cs = dict(\\n number_collisions=number_collisions,\\n cost_collisions=number_collisions,\\n # Drone should not leave valid operation space...\\n cost_out_of_range=(1. if z > 2 else 0.)\\n )\\n # sum all costs in one total cost\\n cs['cost'] = min(1, sum(v for k, v in cs.items() if k.startswith('cost_')))\\n return cs\",\n \"def total_cost(self):\\r\\n return sum(i.line_cost for i in self.orderitem_set.filter(status=self.status)) # pylint: disable=E1101\\r\",\n \"def cost_total(X, cost_weights=(1.0, 1.0, 1.0)):\\n return cost_weights[0] * cost_distance(X) + \\\\\\n cost_weights[1] * cost_same_team_by_distance(X) + \\\\\\n cost_weights[2] * cost_previous_neighbour_by_distance(X, normalize=True)\",\n \"def calculateCosts(self):\\n self.costs = 0\\n for house in self.houses:\\n if not house.distance == 1000:\\n self.costs += house.distance * 9\\n for battery in self.batteries:\\n self.costs += battery.costs\\n return self.costs\",\n \"def ord_costs(costs, FILE):\\r\\n list = []\\r\\n list = sorted(costs, key = get_sum_of_money)\\r\\n list.reverse()\\r\\n save_list_json(list, FILE)\\r\\n return list\",\n \"def total_cost(self):\\n return np.einsum('i->', self.c[self.s])\",\n \"def get_cost_and_weight_of_knapsack(solution,weight_cost):\\r\\n cost,weight = 0,0 \\r\\n for item in solution:\\r\\n weight += weight_cost[item][0]\\r\\n cost += weight_cost[item][1]\\r\\n return cost,weight\",\n \"def calculate_cost(self):\\n costs = {}\\n if np.abs(self.agent.get_position()[1]) > self.y_lim:\\n costs['cost_outside_bounds'] = 1.\\n if self.agent.velocity_violation:\\n costs['cost_velocity_violation'] = 1.\\n # sum all costs in one total cost\\n costs['cost'] = min(1, sum(v for k, v in costs.items() if k.startswith('cost_')))\\n return costs\",\n \"def SumTotalCost():\\n\\n logs.logger.debug(\\\"Start to add all amount of Cost objects.\\\")\\n try:\\n sumTotal = 0\\n for item in GetAllAmountOfCost():\\n sumTotal += item\\n logs.logger.info(\\\"Add all amount of Cost objects.\\\")\\n return sumTotal\\n except Exception as e:\\n logs.logger.error(e, exc_info=True)\",\n \"def total_cost(self, system=None):\\n system = system or self.system()\\n if system == 'grid':\\n cost = self['system (grid)']['internal system nodal cost']\\n else:\\n cost = self['system (%s)' % system]['system nodal cost']\\n cost = float(cost)\\n return cost\",\n \"def total_cost(self):\\n if self.goal:\\n return self.goal + (self.community_contribution or 0)\\n else:\\n return 0\",\n \"def compute_cost(AL, Y):\\n pass\",\n \"def calc_cost(self):\\n cost = 0\\n for i,[source, sinks] in enumerate(self.nets):\\n self.costs[i] = self.calc_half_perimeter(source, sinks)\\n cost += self.costs[i]\\n self.cost = cost\\n return True\",\n \"def cost(self, n_batteries, houseList, wireCost, batteryCost):\\n\\n\\t\\tcost = 0\\n\\t\\tcost += n_batteries*batteryCost\\n\\t\\tfor house in houseList:\\n\\t\\t\\tcost += self.manhattenDistance(house.position, house.batteryAssignment.position)*wireCost\\n\\t\\treturn cost\",\n \"def total_management_cost(self):\\n total = 0\\n total += self.output_dict['insurance_usd']\\n total += self.output_dict['construction_permitting_usd']\\n total += self.output_dict['bonding_usd']\\n total += self.output_dict['project_management_usd']\\n total += self.output_dict['markup_contingency_usd']\\n total += self.output_dict['engineering_usd']\\n total += self.output_dict['site_facility_usd']\\n return total\",\n \"def get_total_cost(self):\\n total_cost = sum([item.quantity * item.product.price for item in self.orderitem_set.all()])\\n return total_cost - total_cost * (self.discount / Decimal('100'))\",\n \"def compute_cost(AL, Y):\\n pass\",\n \"def final_cost(self):\\n return self.algorithm_results[-1].final_cost\",\n \"def print_solution(data, manager, routing, solution):\\n # create a file in order to save the solution steps.\\n sol_fpath = gbo.create_results_name()\\n print(f'Objective: {solution.ObjectiveValue()}')\\n max_route_distance = 0\\n for vehicle_id in range(data['num_vehicles']):\\n index = routing.Start(vehicle_id)\\n plan_output = 'Route for vehicle {}:\\\\n'.format(vehicle_id)\\n route_distance = 0\\n while not routing.IsEnd(index):\\n plan_output += ' {} -> '.format(manager.IndexToNode(index))\\n previous_index = index\\n index = solution.Value(routing.NextVar(index))\\n route_distance += routing.GetArcCostForVehicle(\\n previous_index, index, vehicle_id)\\n plan_output += '{}\\\\n'.format(manager.IndexToNode(index))\\n plan_output += 'Distance of the route: {}m\\\\n'.format(route_distance)\\n print(plan_output)\\n gbo.write_solution_to_file(sol_fpath, plan_output)\\n max_route_distance = max(route_distance, max_route_distance)\\n print('Maximum of the route distances: {}m'.format(max_route_distance))\\n gbo.write_solution_to_file(sol_fpath, \\\"route distance: \\\"+str(max_route_distance))\",\n \"def print_solution(data, manager, routing, solution):\\r\\n time_dimension = routing.GetDimensionOrDie('Time')\\r\\n total_distance = 0\\r\\n total_load = 0\\r\\n total_time = 0\\r\\n for vehicle_id in range(data['num_vehicles']):\\r\\n index = routing.Start(vehicle_id)\\r\\n plan_output = 'Route for vehicle {}:\\\\n'.format(vehicle_id)\\r\\n route_distance = 0\\r\\n route_load = 0\\r\\n while not routing.IsEnd(index):\\r\\n node_index = manager.IndexToNode(index)\\r\\n route_load = route_load + data['demands'][node_index]\\r\\n time_var = time_dimension.CumulVar(index)\\r\\n plan_output += ' {0} Load({1}) Time({2},{3}) -> '.format(node_index, route_load,\\r\\n solution.Min(time_var), solution.Max(time_var))\\r\\n previous_index = index\\r\\n index = solution.Value(routing.NextVar(index))\\r\\n route_distance += routing.GetArcCostForVehicle(previous_index, index, vehicle_id)\\r\\n time_var = time_dimension.CumulVar(index)\\r\\n plan_output += ' {0} Load({1}) Time({2},{3})\\\\n'.format(manager.IndexToNode(index), route_load,\\r\\n solution.Min(time_var), solution.Max(time_var))\\r\\n plan_output += 'Distance of the route: {}m\\\\n'.format(route_distance)\\r\\n plan_output += 'Load of the route: {}\\\\n'.format(route_load)\\r\\n plan_output += 'Time of the route: {}min\\\\n'.format(solution.Min(time_var))\\r\\n print(plan_output)\\r\\n total_distance += route_distance\\r\\n total_load += route_load\\r\\n total_time += solution.Min(time_var)\\r\\n print('Total distance of all routes: {}m'.format(total_distance))\\r\\n print('Total load of all routes: {}'.format(total_load))\\r\\n print('Total time of all routes: {}min'.format(total_time))\",\n \"def calculate_costs(self):\\n cost_matrix = self.make_cost_matrix()\\n \\n if self.greedy:\\n # Riesen et al., \\\"Greedy Graph Edit Distance\\\"\\n costs = []\\n psi = []\\n \\n for row in range(self.N):\\n phi = self.M\\n row_min = sys.maxint\\n for column in range(self.N+self.M):\\n if column not in psi:\\n if cost_matrix[row, column] < row_min:\\n row_min = cost_matrix[row, column]\\n phi = column\\n \\n costs.append(row_min)\\n if phi < self.M:\\n psi.append(phi)\\n \\n for row in range(self.N, self.N+self.M):\\n if (row - self.N) not in psi:\\n costs.append(cost_matrix[row, row - self.N])\\n else:\\n # Riesen & Bunke, \\\"Approximate graph edit distance computation by means of bipartite graph matching\\\"\\n row_ind, col_ind = optimize.linear_sum_assignment(cost_matrix)\\n \\n if self.verbose:\\n for row, column in (row_ind, col_ind):\\n value = cost_matrix[row, column]\\n print '%d, %d, %.4f' % (row, column, value)\\n \\n return row_ind, col_ind, cost_matrix[row_ind, col_ind]\",\n \"def print_solution(data, manager, routing, assignment):\\r\\n total_distance = 0\\r\\n total_load = 0\\r\\n for vehicle_id in range(data['num_vehicles']):\\r\\n index = routing.Start(vehicle_id)\\r\\n plan_output = 'Route for vehicle {}:\\\\n'.format(vehicle_id+1)\\r\\n route_distance = 0\\r\\n route_load = 0\\r\\n while not routing.IsEnd(index):\\r\\n node_index = manager.IndexToNode(index)\\r\\n route_load += data['demands'][node_index]\\r\\n plan_output += ' {0} Load({1}) -> '.format(node_index, route_load)\\r\\n previous_index = index\\r\\n index = assignment.Value(routing.NextVar(index))\\r\\n route_distance += routing.GetArcCostForVehicle(\\r\\n previous_index, index, vehicle_id)\\r\\n plan_output += ' {0} Load({1})\\\\n'.format(manager.IndexToNode(index),\\r\\n route_load)\\r\\n plan_output += 'Distance of the route: {}m\\\\n'.format(route_distance)\\r\\n plan_output += 'Load of the route: {}\\\\n'.format(route_load)\\r\\n print(plan_output)\\r\\n total_distance += route_distance\\r\\n total_load += route_load\\r\\n print('Total distance of all routes: {}m'.format(total_distance))\\r\\n print('Total load of all routes: {}'.format(total_load))\",\n \"def total_cost(self, X, Y, thetas = None):\\n \\n if thetas == None:\\n thetas = self.thetas\\n \\n J = 0.0\\n m = X.shape[0]\\n for x, true_indx in zip(X, Y):\\n y = np.zeros(self.noutputs)\\n y[true_indx] = 1.\\n h_theta = self._forward_prop(x, thetas)[-1]\\n J += self.cost(h_theta, y)\\n \\n return np.sum(J)/m\",\n \"def calculate_cost_for_certificate_batch(self):\\n num_inputs = 1\\n # output per recipient\\n num_outputs = len(self.certificates_to_issue)\\n # plus revocation outputs\\n num_outputs += sum(1 for c in self.certificates_to_issue.values() if c.revocation_key)\\n # plus global revocation, change output, and OP_RETURN\\n num_outputs += 3\\n self.total = tx_utils.calculate_tx_total(self.tx_cost_constants, num_inputs, num_outputs)\\n return self.total\",\n \"def heuristic_cal(current: list, goal: list) -> int:\\n\\n current_locations = state_to_locations(current)\\n goal_locations = state_to_locations(goal)\\n\\n h_val = 0 # Tracks the cost of the heuristic function\\n for i in range(1, 16):\\n h_val += (abs(current_locations[i][0] - goal_locations[i][0]) +\\n abs(current_locations[i][1] - goal_locations[i][1]))\\n \\\"\\\"\\\" Loops through both lists of locations and adds the Manhattan distance \\n of each number to the sum h_val. The range is from 1 to 16 because the \\n blank in either state is not taken into account.\\\"\\\"\\\"\\n\\n return h_val\",\n \"def out_calc_e_total(target, fp_lst):\\r\\n e_total_list = []\\r\\n\\r\\n for in_node in range(n_hidden): # For each hidden layer node\\r\\n for out_node in range(n_output): # Find ETotal for weight connected to each output node\\r\\n e_total = -1 * (target[out_node] - fp_lst[1][out_node]) * fp_lst[1][out_node] * (\\r\\n 1 - fp_lst[1][out_node]) * fp_lst[0][in_node]\\r\\n\\r\\n e_total_list.append(e_total)\\r\\n\\r\\n return e_total_list\",\n \"def sim_average_cost(self, dictionary):\\n\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\tprint \\\"Running: sim_average_cost\\\"\\n\\t\\tf = open(toggles.OUTPUT_PATH + toggles.RUN_NAME + '_estimated_costs.csv', 'a')\\n\\n\\t\\tfor p in toggles.CHOSEN_PREDS:\\n\\t\\t\\tpred_cost = 0.0\\n\\t\\t\\tpred = Predicate.objects.all().get(pk=p+1)\\n\\t\\t\\tf.write(pred.question.question_text + '\\\\n')\\n\\n\\t\\t\\t#iterate through to find each ip cost\\n\\t\\t\\tfor ip in IP_Pair.objects.filter(predicate=pred):\\n\\t\\t\\t\\titem_cost = 0.0\\n\\t\\t\\t\\t# sample toggles.COST_SAMPLES times\\n\\t\\t\\t\\tfor x in range(toggles.COST_SAMPLES):\\n\\t\\t\\t\\t\\t# running one sampling\\n\\t\\t\\t\\t\\twhile ip.status_votes < toggles.NUM_CERTAIN_VOTES:\\n\\t\\t\\t\\t\\t\\t# get the vote\\n\\t\\t\\t\\t\\t\\tvalue = choice(dictionary[ip])\\n\\t\\t\\t\\t\\t\\tif value == True:\\n\\t\\t\\t\\t\\t\\t\\tip.value += 1\\n\\t\\t\\t\\t\\t\\t\\tip.num_yes += 1\\n\\t\\t\\t\\t\\t\\telif value == False:\\n\\t\\t\\t\\t\\t\\t\\tip.value -= 1\\n\\t\\t\\t\\t\\t\\t\\tip.num_no +=1\\n\\n\\t\\t\\t\\t\\t\\tip.status_votes += 1\\n\\n\\t\\t\\t\\t\\t\\t# check if ip is done\\n\\t\\t\\t\\t\\t\\tif ip.status_votes == toggles.NUM_CERTAIN_VOTES:\\n\\t\\t\\t\\t\\t\\t\\t\\tif ip.value > 0:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tuncertaintyLevel = btdtr(ip.num_yes+1, ip.num_no+1, toggles.DECISION_THRESHOLD)\\n\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tuncertaintyLevel = btdtr(ip.num_no+1, ip.num_yes+1, toggles.DECISION_THRESHOLD)\\n\\t\\t\\t\\t\\t\\t\\t\\tif uncertaintyLevel < toggles.UNCERTAINTY_THRESHOLD:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\titem_cost += (ip.num_yes + ip.num_no)\\n\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tip.status_votes -= 2\\n\\n\\t\\t\\t\\t\\t# reset values\\n\\t\\t\\t\\t\\tip.value = 0\\n\\t\\t\\t\\t\\tip.num_yes = 0\\n\\t\\t\\t\\t\\tip.num_no = 0\\n\\t\\t\\t\\t\\tip.status_votes = 0\\n\\n\\t\\t\\t\\titem_cost = item_cost/float(toggles.COST_SAMPLES)\\n\\t\\t\\t\\tpred_cost += item_cost\\n\\t\\t\\t\\tf.write(ip.item.name + ': ' + str(item_cost) + \\\" \\\")\\n\\n\\t\\t\\tpred_cost = float(pred_cost)/IP_Pair.objects.filter(predicate=pred).count()\\n\\t\\t\\tf.write('\\\\npredicate average cost: ' + str(pred_cost) + '\\\\n \\\\n')\\n\\t\\tf.close()\\n\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\tprint \\\"Wrote File: \\\" + toggles.OUTPUT_PATH + toggles.RUN_NAME + '_estimated_costs.csv'\",\n \"def get_cost(self) -> float:\\n return math.e / self.fitness\",\n \"def quadratic_cost(output_out, target_out):\\r\\n total = 0\\r\\n for target_node in range(len(target_out)): # For each target data set\\r\\n for output_node in range(len(output_out)): # For each output node\\r\\n total += (0.5 * (target_out[target_node][output_node] - output_out[output_node])) ** 2\\r\\n\\r\\n total = 1 / total\\r\\n return total\",\n \"def compute_fitness(solution):\\n\\n solution_fitness = 0.0\\n\\n for index in range(len(solution)):\\n waypoint1 = solution[index - 1]\\n waypoint2 = solution[index]\\n solution_fitness += waypoint_distances[frozenset([waypoint1, waypoint2])]\\n\\n return solution_fitness\",\n \"def cost(foods, foods_used):\\n cost = 0.00\\n for i, count in foods_used.items():\\n cost += (foods[i]['serving_cost'] * count)\\n return cost\",\n \"def update_current_sol_and_cost(self,sol=None):\\n\\n # Update current sol if argument given\\n if sol is not None:\\n self.current_sol = sol\\n \\n # Update residual and cost\\n try:\\n self.residual = self.sketch_reweighted - self.sketch_of_solution(self.current_sol)\\n self.current_sol_cost = np.linalg.norm(self.residual)\\n except AttributeError: # We are here if self.current_sol does not exist yet\\n self.current_sol, self.residual = None, self.sketch_reweighted\\n self.current_sol_cost = np.inf\",\n \"def update_totals(self):\\n # Reset counts to 0\\n self.total_f = self.total_s = self.total_intra = self.total_mac_regular = self.total_mac_infected = \\\\\\n self.total_mac_activated = self.total_regular_fast = self.total_regular_slow = self.total_infected_fast = \\\\\\n self.total_infected_slow = self.total_activated_fast = self.total_activated_slow = self.total_f_degree = \\\\\\n self.total_s_degree = self.total_activation = 0\\n self.total_f_o2 = self.total_s_o2 = 0.0\\n\\n for node in self.node_list.values():\\n # Get values from node\\n fast_in_node = node.subpopulations[BACTERIA_FAST]\\n slow_in_node = node.subpopulations[BACTERIA_SLOW]\\n intra_in_node = node.subpopulations[BACTERIA_INTRACELLULAR]\\n reg_mac_in_node = node.subpopulations[MACROPHAGE_REGULAR]\\n inf_mac_in_node = node.subpopulations[MACROPHAGE_INFECTED]\\n act_mac_in_node = node.subpopulations[MACROPHAGE_ACTIVATED]\\n degree = node.degree\\n o2_tens = node.oxygen_tension\\n # Update relevant totals\\n self.total_f += fast_in_node\\n self.total_s += slow_in_node\\n self.total_intra += intra_in_node\\n self.total_mac_regular += reg_mac_in_node\\n self.total_mac_infected += inf_mac_in_node\\n self.total_mac_activated += act_mac_in_node\\n self.total_regular_fast += fast_in_node * reg_mac_in_node\\n self.total_regular_slow += slow_in_node * reg_mac_in_node\\n self.total_infected_fast += fast_in_node * inf_mac_in_node\\n self.total_infected_slow += slow_in_node * inf_mac_in_node\\n self.total_activated_fast += fast_in_node * act_mac_in_node\\n self.total_activated_slow += slow_in_node * act_mac_in_node\\n # TODO - check usage of degree\\n self.total_f_degree += fast_in_node * degree\\n self.total_s_degree += slow_in_node * degree\\n self.total_f_o2 += fast_in_node * (1/o2_tens)\\n self.total_s_o2 += slow_in_node * o2_tens\\n self.total_activation += reg_mac_in_node * inf_mac_in_node\",\n \"def dv_update(self, dv_list):\\n for line in dv_list:\\n line_sep = line.split(',')\\n other_name = line_sep[0] + ':' + line_sep[1]\\n other_cost = float(line_sep[2])\\n self.distance_vector[other_name] = other_cost\",\n \"def get_cost(self):\\n if self.distance == 0:\\n for i in range(1, len(self.cities) + 1):\\n point1 = self.cities[i - 1]\\n point2 = self.cities[i % len(self.cities)]\\n self.distance += self.distance_to(point1, point2)\\n return self.distance\",\n \"def compute_tour_cost(self, list_cities: list) -> float:\\n cost = 0.0\\n n = self.tour_size # Number of cities\\n for i in range(n):\\n if i + 1 < n:\\n cost += list_cities[self.tour_ids[i]].distance(list_cities[self.tour_ids[i + 1]])\\n else:\\n cost += list_cities[self.tour_ids[i]].distance(list_cities[self.tour_ids[0]])\\n\\n return cost\",\n \"def cost(solution):\\n cost = 0\\n alm_count = 0 # alignment operand/operator count\\n fst_len = len(solution[0])\\n snd_len = len(solution[1])\\n min_len = min(fst_len, snd_len)\\n\\n for i in range(min_len):\\n if solution[0][i] == solution[1][i]:\\n alm_count += 1\\n\\n max_spaces = max(solution[0].count(\\\" \\\"), solution[1].count(\\\" \\\"))\\n cost = ((alm_count * 2.0) + max_spaces) / 3.0\\n\\n return cost\",\n \"def cost(self):\\n abs_cost = sum(f['price'] * f['qty'] for f in self.fills)\\n return -abs_cost if self.is_ask() else abs_cost\",\n \"def cost(self):\\n node, path_back = self, []\\n cost = 0\\n while node:\\n path_back.append(node)\\n if node.action is not None:\\n cost = cost + node.action.cost\\n node = node.parent\\n # remove one due to root empty node \\n #cost = cost-1\\n return [cost, list(reversed(path_back))]\",\n \"def cost(cost: List[float]) -> List[float]:\\n\\n data = pd.DataFrame({'cost':np.array(cost).clip(min=0)})\\n data['cost'] = data['cost'].rolling(window=data.shape[0],min_periods=1).sum()\\n \\n return data['cost'].tolist()\",\n \"def total_cost(path: Path) -> float:\\n\\t\\n\\tdistance = calc_total_dist(path)\\n\\tavg_speed = calc_average_speed(path)\\n\\t\\n\\t# Speed is less important, but gets a huge multiplier, because speed and\\n\\t# \\tdistance are in different units. Speed requires a high ratio to have\\n\\t# \\tsimilar amounts of variation.\\n\\tSPEED_DISTANCE_COST_RATIO = 7865.099\\n\\t\\n\\treturn (\\n\\t\\t(distance * 1) +\\n\\t\\t(-avg_speed * SPEED_DISTANCE_COST_RATIO)\\n\\t)\",\n \"def calculate_expected_cost(melon_cost, melon_count):\\n\\n return melon_cost + melon_count\",\n \"def cost_function(self, config_samples):\\n cost = self.work_tracker(config_samples)\\n return cost\",\n \"def __cost_to_goal(self, goal_state):\\n cost = 0\\n for i in range(len(goal_state) * len(goal_state[0])):\\n if(i != 0):\\n pos_goal = self.__get_position(i, goal_state)\\n pos_current = self.__get_position(i, self.puzzle)\\n cost += self.__manhattan(pos_current[0], pos_current[1], pos_goal[0], pos_goal[1])\\n return cost\",\n \"def dp_all(foods, cal_goal, pro_goal, carb_goal, fat_goal):\\n costs = init_four_d_array((cal_goal, pro_goal, carb_goal, fat_goal),\\n 999999999)\\n foods_used = init_four_d_array((cal_goal, pro_goal, carb_goal, fat_goal),\\n {})\\n\\n for i in range(cal_goal):\\n for j in range(pro_goal):\\n for k in range(carb_goal):\\n for l in range(fat_goal):\\n for n in range(len(foods)):\\n food = foods[n]\\n if (int(food['calories']) > i\\n or int(food['protein']) > j\\n or int(food['carbs']) > k\\n or int(food['fat']) > l):\\n continue\\n if (costs[i - int(food['calories'])]\\n [j - int(food['protein'])]\\n [k - int(food['carbs'])]\\n [l - int(food['fat'])]\\n == 999999999):\\n prev_cost = 0\\n prev_foods_used = {}\\n else:\\n prev_cost = (macros[i - int(food['calories'])]\\n [j - int(food['protein'])]\\n [j - int(food['carbs'])]\\n [j - int(food['fat'])])\\n prev_foods_used = \\\\\\n (foods_used[i - int(food['calories'])]\\n [j - int(food['protein'])]\\n [k - int(food['carbs'])]\\n [l - int(food['fat'])]).copy()\\n new_cal = calories(\\n foods, prev_foods_used) + food['calories']\\n new_pro = protein(\\n foods, prev_foods_used) + food['protein']\\n new_car = carbs(\\n foods, prev_foods_used) + food['protein']\\n new_fat = fat(\\n foods, prev_foods_used) + food['protein']\\n if (costs[i][j] > prev_cost + food['serving_cost']\\n and new_cal > i - 20 and new_cal < i + 10\\n and new_pro < j + 5 and new_pro < j + 5\\n and new_car < j + 5 and new_car < j + 5\\n and new_fat < j + 5 and new_fat < j + 5):\\n costs[i][j][k][l] = prev_cost + \\\\\\n food['serving_cost']\\n try:\\n prev_foods_used[n] += 1\\n except KeyError:\\n prev_foods_used[n] = 1\\n foods_used[i][j][k][l] = prev_foods_used\\n return foods_used[cal_goal - 1][pro_goal - 1][carb_goal - 1][fat_goal - 1]\",\n \"def cost(self):\\n\\t\\treturn self.g + self.h\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n n = Directions.NORTH\\n e = Directions.EAST\\n\\n result = []\\n qu = util.PriorityQueue()\\n visited = set([])\\n current = (problem.getStartState(), \\\"\\\", 0)\\n qu.update(current, 0)\\n costs = {}\\n parents = {}\\n parents[problem.getStartState()] = (problem.getStartState(), \\\"\\\")\\n\\n while not qu.isEmpty():\\n cost, current= qu.pop()\\n visited.add(current[0])\\n\\n if problem.isGoalState(current[0]):\\n result = current[0]\\n break\\n\\n for each in problem.getSuccessors(current[0]):\\n if each[0] not in visited:\\n qu.update(each, cost+each[2])\\n if each[0] not in costs:\\n costs[each[0]] = cost+each[2]\\n parents[each[0]] = (current[0], each[1])\\n elif costs[each[0]] > cost+each[2]:\\n costs[each[0]] = cost + each[2]\\n parents[each[0]] = (current[0], each[1])\\n\\n path = []\\n while parents[result][0] != result:\\n path.append(parents[result][1])\\n result = parents[result][0]\\n\\n path.reverse()\\n result = []\\n for each in path:\\n if each == \\\"South\\\":\\n result.append(s)\\n elif each == \\\"West\\\":\\n result.append(w)\\n elif each == \\\"North\\\":\\n result.append(n)\\n elif each == \\\"East\\\":\\n result.append(e)\\n\\n return result\\n util.raiseNotDefined()\",\n \"def get_cost_updates(self):\\n\\n y = self.get_hidden_values()\\n z = self.get_reconstructed_input(y)\\n\\n L = T.sum((self.x-z)**2, axis=1)\\n\\n cost = T.mean(L)\\n\\n return cost\",\n \"def cost(self, output, labels, weights):\\n raise NotImplementedError('Must be overridden by concrete subclass')\",\n \"def get_hcost(self):\\n hvcost = self.get_hvcost()\\n dcost = self.get_dcost()\\n hcost = hvcost + dcost\\n return hcost\",\n \"def get_sol(self):\",\n \"def execution_cost(self):\\n #TODO: Compute execution cost\\n total_cost = 0\\n for res_cfg in self.resource_configurations:\\n mapped_tasks = list(filter(lambda x: x.resource_schedule.config == res_cfg, self.schedule_mapping_list))\\n makespan_res = SchedulePlan._makespan(mapped_tasks)\\n total_cost += makespan_res * res_cfg.cost_hour_usd\\n return total_cost\",\n \"def cost_function(self, element):\\n return self.maze.cost(element)\",\n \"def total_cost(self, J_content, J_style, alpha=10, beta=40):\\n\\n J_total_cost = alpha * J_content + beta * J_style\\n\\n return J_total_cost\",\n \"def cost(self):\\n return self._cost\",\n \"def cost(self):\\n return self._cost\",\n \"def route_cost(self, route):\\n total_weight = 0\\n c = 0\\n start = route[0]\\n for end in route[1:]:\\n y = float(self.stars[start][end]['weight']) - c\\n t = total_weight + y\\n c = (t - total_weight) - y\\n\\n total_weight = t\\n\\n start = end\\n return total_weight\",\n \"def run_solution1_simple(self):\\n fuel_sum = 0\\n for n in self.data:\\n fuel_sum += self.calculate_fuel(n)\\n return fuel_sum\",\n \"def write_solutions_to_files(\\n solutions: List[Solution], path: Path, folder_name: str = \\\"CodeWars\\\"\\n) -> None:\\n stat = {}\\n path = path / folder_name\\n for solution in solutions:\\n if solution.kyu in stat:\\n stat[solution.kyu] += 1\\n else:\\n stat[solution.kyu] = 1\\n\\n path_to_solution = get_dir(solution, path)\\n path_to_solution.mkdir(parents=True, exist_ok=True)\\n\\n create_file(\\n path_to_solution / f\\\"main{EXTENSIONS[solution.language]}\\\", solution.solution\\n )\\n\\n create_file(path_to_solution / \\\"README.md\\\", f\\\"Link: {solution.link}\\\")\\n\\n kuy_stat = \\\"\\\\n\\\".join([f\\\":star: {x}: {stat[x]} :star:\\\" for x in sorted(stat)])\\n create_file(\\n path / \\\"README.md\\\",\\n f\\\"Total: {sum([stat[x] for x in stat])}\\\\n\\\" f\\\"Detail statistic:\\\\n{kuy_stat}\\\",\\n )\",\n \"def tablecost(self):\\n subtotal_getter = operator.attrgetter(\\\"subtotal\\\")\\n\\n cost = 0.0\\n\\n cost += sum(map(subtotal_getter, self.materials))\\n cost += sum(map(subtotal_getter, self.processes))\\n cost += sum(map(subtotal_getter, self.fasteners))\\n cost += sum(map(subtotal_getter, self.toolings))\\n\\n return cost\",\n \"def print_solution(manager, routing, solution):\\n print('Objective: {} miles'.format(solution.ObjectiveValue()))\\n index = routing.Start(0)\\n plan_output = 'Route for vehicle 0:\\\\n'\\n route_distance = 0\\n while not routing.IsEnd(index):\\n plan_output += ' {} ->'.format(manager.IndexToNode(index))\\n previous_index = index\\n index = solution.Value(routing.NextVar(index))\\n route_distance += routing.GetArcCostForVehicle(previous_index, index, 0)\\n plan_output += ' {}\\\\n'.format(manager.IndexToNode(index))\\n print(plan_output)\\n plan_output += 'Route distance: {}miles\\\\n'.format(route_distance)\",\n \"def print_solution(manager, routing, solution):\\n print('Objective: {} miles'.format(solution.ObjectiveValue()))\\n index = routing.Start(0)\\n plan_output = 'Route for vehicle 0:\\\\n'\\n route_distance = 0\\n while not routing.IsEnd(index):\\n plan_output += ' {} ->'.format(manager.IndexToNode(index))\\n previous_index = index\\n index = solution.Value(routing.NextVar(index))\\n route_distance += routing.GetArcCostForVehicle(previous_index, index, 0)\\n plan_output += ' {}\\\\n'.format(manager.IndexToNode(index))\\n print(plan_output)\\n plan_output += 'Route distance: {}miles\\\\n'.format(route_distance)\",\n \"def twoCitySchedCost(self, costs: List[List[int]]) -> int:\\n def abs_diff_compare(x=[1,2], y=[3,4]):\\n x1=x[0]-x[1] if x[0]>=x[1] else x[1]-x[0]\\n y1=y[0]-y[1] if y[0]>=y[1] else y[1]-x[0]\\n return x1 if x1>y1 else y1\\n save_costs=costs\\n costs.sort(reverse=True, key=abs_diff_compare)\\n print(costs)\\n nA=0\\n nB=0\\n tc=0\\n num_people=len(costs)\\n max_ppl=num_people//2\\n \\n for x in costs:\\n if nA< max_ppl and nB< max_ppl :\\n if x[0] <x[1]:\\n nA+=1\\n tc+=x[0]\\n else:\\n nB+=1\\n tc+=x[1]\\n elif nA< max_ppl:\\n nA+=1\\n tc+=x[0]\\n elif nB< max_ppl:\\n nB+=1\\n tc+=x[1]\\n \\n \\n return tc\",\n \"def evaluate(G, path, home_idxs, verbose=False):\\n dropoffs = assign_dropoffs(G, path, home_idxs)\\n cost, msg = cost_of_solution(G, path, dropoffs, shortest=all_pairs_dists)\\n if verbose:\\n print(msg)\\n\\n return cost\",\n \"def rate(way):\\n cost = 0\\n for i in range(len(way)-1):\\n cost += DISTANCES[way[i]][way[i+1]]\\n return cost\",\n \"def totalValue(self):\\n\\n\\t\\tvalue = 0\\n\\t\\tfor bottle in self.bottles:\\n\\t\\t\\tvalue += bottle.inflatedCost\\n\\n\\t\\treturn value\",\n \"def calculate_cost(self, **kwargs):\\n costs = {}\\n if np.abs(self.agent.get_position()[0]) > self.x_lim:\\n costs['cost_outside_bounds'] = 1.\\n # sum all costs in one total cost\\n costs['cost'] = min(1, sum(v for k, v in costs.items() if k.startswith('cost_')))\\n\\n return costs\",\n \"def computeAssignments(solution, h, data, sumW, checkers, hini=None):\\n minHours = data[\\\"minHours\\\"]\\n hours = data[\\\"hours\\\"]\\n z = solution[\\\"z\\\"]\\n w = solution[\\\"w\\\"]\\n\\n mustWork = []\\n canWork = []\\n\\n # sort nurses, first by those who work\\n sorted_nurses = sorted(range(data[\\\"nNurses\\\"]), key=lambda n: solution[\\\"z\\\"][n], reverse=True)\\n # print(solution[\\\"z\\\"])\\n # print(sorted_nurses)\\n # print(\\\"\\\")\\n\\n # for each nurse\\n for n in sorted_nurses:\\n\\n # canWork Check-------------------------------\\n canWork_check = checkIfCanWork_fast(solution, h, n, data, sumW, checkers=checkers, hini=hini)\\n if canWork_check:\\n\\n\\n mustWork_check = checkIfMustWork_fast(solution, h, n, data, sumW, True, checkers, hini)\\n if mustWork_check:\\n mustWork.append(n)\\n else: \\n canWork.append(n)\\n\\n # # mustWork Check-------------------------------\\n # # avoid repeating canWork_check\\n # mustWork_check = checkIfMustWork_fast(solution, h, n, data, sumW, canWork_check, checkers, hini)\\n # if mustWork_check:\\n # mustWork.append(n)\\n # else:\\n \\n return mustWork, canWork\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60077643","0.59991765","0.5897307","0.5896258","0.5895152","0.5890144","0.5856607","0.58172816","0.5780239","0.5713375","0.5707637","0.57038105","0.57038105","0.5679921","0.5667275","0.5651229","0.5595291","0.5590735","0.55840975","0.5565297","0.55651796","0.5548572","0.5540117","0.55382615","0.5531154","0.5490516","0.5482165","0.5449843","0.5437292","0.5432133","0.5414476","0.5409725","0.54028267","0.5395686","0.5394704","0.53688854","0.53600526","0.5347442","0.5341647","0.53378505","0.533197","0.53281415","0.53105986","0.53062725","0.5296767","0.52786964","0.52648556","0.52535045","0.52509874","0.52412707","0.5241189","0.52391803","0.52351785","0.5222319","0.52074105","0.52052104","0.51985854","0.519635","0.5186965","0.516671","0.51656854","0.51638395","0.5155154","0.5137614","0.513539","0.51350224","0.5129932","0.51299083","0.51270926","0.5126487","0.5126454","0.5119741","0.51094496","0.5097478","0.5096802","0.5093359","0.5088679","0.5084697","0.50805724","0.50720596","0.506789","0.50656193","0.50622284","0.5060945","0.504841","0.50428504","0.5041951","0.5041951","0.50411236","0.50389796","0.50357205","0.50138086","0.5013","0.5012315","0.500515","0.49981615","0.4993289","0.49923727","0.49863172","0.49846405"],"string":"[\n \"0.60077643\",\n \"0.59991765\",\n \"0.5897307\",\n \"0.5896258\",\n \"0.5895152\",\n \"0.5890144\",\n \"0.5856607\",\n \"0.58172816\",\n \"0.5780239\",\n \"0.5713375\",\n \"0.5707637\",\n \"0.57038105\",\n \"0.57038105\",\n \"0.5679921\",\n \"0.5667275\",\n \"0.5651229\",\n \"0.5595291\",\n \"0.5590735\",\n \"0.55840975\",\n \"0.5565297\",\n \"0.55651796\",\n \"0.5548572\",\n \"0.5540117\",\n \"0.55382615\",\n \"0.5531154\",\n \"0.5490516\",\n \"0.5482165\",\n \"0.5449843\",\n \"0.5437292\",\n \"0.5432133\",\n \"0.5414476\",\n \"0.5409725\",\n \"0.54028267\",\n \"0.5395686\",\n \"0.5394704\",\n \"0.53688854\",\n \"0.53600526\",\n \"0.5347442\",\n \"0.5341647\",\n \"0.53378505\",\n \"0.533197\",\n \"0.53281415\",\n \"0.53105986\",\n \"0.53062725\",\n \"0.5296767\",\n \"0.52786964\",\n \"0.52648556\",\n \"0.52535045\",\n \"0.52509874\",\n \"0.52412707\",\n \"0.5241189\",\n \"0.52391803\",\n \"0.52351785\",\n \"0.5222319\",\n \"0.52074105\",\n \"0.52052104\",\n \"0.51985854\",\n \"0.519635\",\n \"0.5186965\",\n \"0.516671\",\n \"0.51656854\",\n \"0.51638395\",\n \"0.5155154\",\n \"0.5137614\",\n \"0.513539\",\n \"0.51350224\",\n \"0.5129932\",\n \"0.51299083\",\n \"0.51270926\",\n \"0.5126487\",\n \"0.5126454\",\n \"0.5119741\",\n \"0.51094496\",\n \"0.5097478\",\n \"0.5096802\",\n \"0.5093359\",\n \"0.5088679\",\n \"0.5084697\",\n \"0.50805724\",\n \"0.50720596\",\n \"0.506789\",\n \"0.50656193\",\n \"0.50622284\",\n \"0.5060945\",\n \"0.504841\",\n \"0.50428504\",\n \"0.5041951\",\n \"0.5041951\",\n \"0.50411236\",\n \"0.50389796\",\n \"0.50357205\",\n \"0.50138086\",\n \"0.5013\",\n \"0.5012315\",\n \"0.500515\",\n \"0.49981615\",\n \"0.4993289\",\n \"0.49923727\",\n \"0.49863172\",\n \"0.49846405\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5381247"},"document_rank":{"kind":"string","value":"35"}}},{"rowIdx":24599,"cells":{"query":{"kind":"string","value":"Given the solution saved in list, calculate the total cost of the solution. Write the solution to local in the required format."},"document":{"kind":"string","value":"def print_route_detail(self, solution, vehicle_type, if_write):\r\n\r\n result = [[\r\n '线路编号',\r\n '门店编码',\r\n '门店名称',\r\n '门店地址',\r\n '经度',\r\n '纬度',\r\n '车型',\r\n '额定体积/m3',\r\n '额定重量/t',\r\n '到达时间',\r\n '离开时间',\r\n '行驶距离/km',\r\n '累计行驶距离km',\r\n '行驶时间/min',\r\n '卸货时间/min',\r\n '累计工作时间/h',\r\n '鲜食篮总数',\r\n '周转箱个数',\r\n '新绿园鲜奶980ML（罐）',\r\n '新绿园脱脂牛奶980ML（罐）',\r\n '纸箱个数',\r\n '卸货体积',\r\n '卸货重量']]\r\n\r\n total_dist = 0\r\n for k, veh in enumerate(solution):\r\n if vehicle_type[k] == 2:\r\n trans0 = small_veh[4]\r\n veh_param = small_veh\r\n\r\n elif vehicle_type[k] == 3:\r\n trans0 = medium_veh[4]\r\n veh_param = medium_veh\r\n\r\n else:\r\n trans0 = large_veh[4]\r\n veh_param = large_veh\r\n\r\n\r\n departt = check_violation(veh, vehicle_type[k])[3]\r\n t = departt\r\n\r\n trvl_dist = 0\r\n veh_load_vol = 0\r\n wait_time = 0\r\n\r\n veh_load_vol += (num_demd[veh[1]][0] * bskt_vol + num_demd[veh[1]][1] * trsf_vol + (num_demd[veh[1]][2] +\r\n num_demd[veh[1]][3]) * milk_vol + num_demd[veh[1]][4] * paper_bskt)\r\n if departt / 60. < 24.:\r\n out_time = int(math.ceil(departt))\r\n else:\r\n out_time = int(math.ceil(departt - 24 * 60))\r\n\r\n # get the output format\r\n store = [0] * len(result[0])\r\n store[0] = k + 1 # 线路序号\r\n store[1] = num_id[0][0] # 门店编号\r\n store[2] = num_id[0][1] # 门店名称\r\n store[3] = num_id[0][2] # 门店地址\r\n store[4] = loc[0][0] # 经度\r\n store[5] = loc[0][1] # 纬度\r\n store[6] = vehicle_type_dict[vehicle_type[k]] # 车型\r\n store[7] = veh_param[2] # 额定体积\r\n store[8] = veh_param[1] # 额定重量\r\n store[9] = str(out_time // 60) + ':' + str(out_time % 60).zfill(2) # 到达时间\r\n store[10] = str(out_time // 60) + ':' + str(out_time % 60).zfill(2) # 离开时间\r\n store[11] = 0 # 行驶距离\r\n store[12] = 0 # 累计行驶距离\r\n store[13] = 0 # 行驶时间\r\n store[14] = 0 # 卸货时间\r\n store[15] = 0 # 累计工作时间\r\n store[16] = 0 # 鲜食篮件数\r\n store[17] = 0 # 周转箱个数\r\n store[18] = 0 # 新绿园鲜奶\r\n store[19] = 0 # 新绿园脱脂牛奶\r\n store[20] = 0 # 纸箱\r\n store[21] = 0 # 卸货体积\r\n store[22] = 0 # 卸货重量\r\n\r\n store0 = copy.deepcopy(store)\r\n result.append(store0)\r\n\r\n # t = departt + time_mat[0, veh[1]] + oprt_t # t is the leaving time\r\n for i in range(1, len(veh)-1): # can not wait at the first 2 points\r\n store[1] = num_id[veh[i]][0]\r\n store[2] = num_id[veh[i]][1]\r\n store[3] = num_id[veh[i]][2]\r\n store[4] = loc[veh[i]][0]\r\n store[5] = loc[veh[i]][1]\r\n arr_time = t + time_mat[veh[i-1], veh[i]]\r\n if arr_time / 60. < 24.:\r\n in_time = int(math.ceil(arr_time))\r\n else:\r\n in_time = int(math.ceil(arr_time - 24 * 60))\r\n\r\n trvl_dist += dist_mat[veh[i-1], veh[i]]\r\n veh_load_vol += (num_demd[veh[i]][0] * bskt_vol + num_demd[veh[i]][1] * trsf_vol + (num_demd[veh[i]][2] +\r\n num_demd[veh[i]][3]) * milk_vol + num_demd[veh[i]][4] * paper_bskt)\r\n wait_t = num_timez[veh[i]][0] - (t + time_mat[veh[i-1], veh[i]])\r\n if wait_t > 0 + 1e-5:\r\n # t is the leaving time\r\n wait_time += wait_t\r\n t = num_timez[veh[i]][0] + oprt_t\r\n else:\r\n t += (time_mat[veh[i - 1], veh[i]] + oprt_t)\r\n if t < 24. * 60:\r\n out_time = int(math.ceil(t))\r\n else:\r\n out_time = int(math.ceil(t - 24 * 60))\r\n\r\n store[9] = str(in_time // 60) + ':' + str(in_time % 60).zfill(2) # 到达时间\r\n store[10] = str(out_time // 60) + ':' + str(out_time % 60).zfill(2) # 离开时间\r\n store[11] = round(dist_mat[veh[i-1], veh[i]] / 1000., 2) # 行驶距离\r\n store[12] = round(trvl_dist / 1000., 2) # 累计行驶距离\r\n store[13] = round(time_mat[veh[i-1], veh[i]], 1) # 行驶时间\r\n store[14] = oprt_t\r\n store[15] = round((t - departt) / 60., 2) # 累计工作时间\r\n store[16] = num_demd[veh[i]][0] # 鲜食篮件数\r\n store[17] = num_demd[veh[i]][1] # 周转箱个数\r\n store[18] = num_demd[veh[i]][2] # 新绿园鲜奶\r\n store[19] = num_demd[veh[i]][3] # 新绿园脱脂牛奶\r\n store[20] = num_demd[veh[i]][4] # 纸箱\r\n store[21] = (num_demd[veh[i]][0] * bskt_vol + num_demd[veh[i]][1] * trsf_vol + (num_demd[veh[i]][2] +\r\n num_demd[veh[i]][3]) * milk_vol + num_demd[veh[i]][4] * paper_bskt) # 卸货体积\r\n store[22] = 0 # 卸货重量\r\n\r\n store0 = copy.deepcopy(store)\r\n result.append(store0)\r\n # print(result[-1])\r\n\r\n store[1] = num_id[0][0] # 门店编号\r\n store[2] = num_id[0][1] # 门店名称\r\n store[3] = num_id[0][2] # 门店地址\r\n store[4] = loc[0][0] # 经度\r\n store[5] = loc[0][1] # 纬度\r\n arr_time = t + time_mat[veh[-2], 0]\r\n if arr_time / 60. < 24.:\r\n in_time = int(math.ceil(arr_time))\r\n else:\r\n in_time = int(math.ceil(arr_time - 24 * 60))\r\n store[9] = str(in_time // 60) + ':' + str(in_time % 60).zfill(2) # 到达时间\r\n store[10] = str(in_time // 60) + ':' + str(in_time % 60).zfill(2) # 离开时间\r\n store[11] = round(dist_mat[veh[-2], 0] / 1000., 2) # 行驶距离\r\n store[12] = round((trvl_dist + dist_mat[veh[-2], 0]) / 1000., 2) # 累计行驶距离\r\n store[13] = round(time_mat[veh[-2], 0], 1) # 行驶时间\r\n store[14] = 0 # 卸货时间\r\n store[15] = round((t - departt + time_mat[veh[-2], 0]) / 60., 2) # 累计工作时间\r\n store[16] = 0 # 鲜食篮件数\r\n store[17] = 0 # 周转箱个数\r\n store[18] = 0 # 新绿园鲜奶\r\n store[19] = 0 # 新绿园脱脂牛奶\r\n store[20] = 0 # 纸箱\r\n store[21] = 0 # 卸货体积\r\n store[22] = 0 # 卸货重量\r\n\r\n store0 = copy.deepcopy(store)\r\n result.append(store0)\r\n # print(result[-1])\r\n\r\n if if_write:\r\n # run_time = time.strftime(\"%m%d_%H%M\", time.localtime())\r\n with open(r'C:\\Bee\\0Huaat\\Starbucks\\output\\Route_Details_%s_%s.csv' % (veh_spd_kmh, run_time), 'w', newline='') as fw:\r\n writer = csv.writer(fw)\r\n for v in result:\r\n # print(v)\r\n writer.writerow(v)"},"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 print_and_save_solution(data, manager, routing, assignment):\n total_distance = 0\n total_load = 0\n routes = []\n for vehicle_id in range(data['num_vehicles']):\n route = []\n index = routing.Start(vehicle_id)\n plan_output = 'Route for vehicle {}:\\n'.format(vehicle_id)\n route_distance = 0\n route_load = 0\n while not routing.IsEnd(index):\n node_index = manager.IndexToNode(index)\n route_load += data['demands'][node_index]\n plan_output += ' {0} Load({1}) -> '.format(node_index, route_load)\n previous_index = index\n index = assignment.Value(routing.NextVar(index))\n route_distance += routing.GetArcCostForVehicle(\n previous_index, index, vehicle_id)\n point = data['all_points'][node_index]\n point['load'] = route_load\n route.append(point)\n plan_output += ' {0} Load({1})\\n'.format(manager.IndexToNode(index),\n route_load)\n plan_output += 'Distance of the route: {}m\\n'.format(route_distance)\n plan_output += 'Load of the route: {}\\n'.format(route_load)\n print(plan_output)\n total_distance += route_distance\n total_load += route_load\n if route_load > 0:\n routes.append({\n 'stops': route,\n 'distance': route_distance,\n 'load': route_load,\n 'number_of_stops': len(route)\n })\n print('Total distance of all routes: {}m'.format(total_distance))\n print('Total load of all routes: {}'.format(total_load))\n with open('./results/capacity_{}_{}.json'.format(DRONES_CAPACITY, MAX_POINT_DEMAND), 'w') as f:\n simplejson.dump({\n 'routes': routes,\n 'total_load': total_load,\n 'total_distance': total_distance,\n 'number_of_drones_used': len(routes),\n 'total_numer_of_stops': sum([x['number_of_stops'] for x in routes])\n }, f)","def calculateCost(self,sol,weights):\n\t\treturn sum([x.value*y if x != None else 0 \\\n\t\t\t\t\tfor x,y in zip(sol,weights)])","def add_cost(costs, cost, FILE):\r\n costs.append(cost)\r\n save_list_json(costs, FILE)\r\n return costs","def total_cost_2D(self, final_list):\n total_cost = 0\n for i in range(len(final_list) - 1):\n temp = self.pairwise_distance(final_list[i], final_list[i + 1])\n total_cost = total_cost + temp\n print(\"Total distance: \" + str(total_cost))","def cost(self) -> float:","def calculate_total_cost(state):\n pass","def print_solution(data, manager, routing, assignment):\n total_distance = 0\n total_load = 0\n for vehicle_id in range(data['num_vehicles']):\n index = routing.Start(vehicle_id)\n plan_output = 'Route for vehicle {}:\\n'.format(vehicle_id)\n route_distance = 0\n route_load = 0\n while not routing.IsEnd(index):\n node_index = manager.IndexToNode(index)\n route_load += data['demands'][node_index]\n plan_output += ' {0} Load({1}) -> '.format(node_index, route_load)\n previous_index = index\n index = assignment.Value(routing.NextVar(index))\n route_distance += routing.GetArcCostForVehicle(\n previous_index, index, vehicle_id)\n plan_output += ' {0} Load({1})\\n'.format(manager.IndexToNode(index),\n route_load)\n plan_output += 'Distance of the route: {}m\\n'.format(route_distance)\n plan_output += 'Load of the route: {}\\n'.format(route_load)\n # print(plan_output)\n total_distance += route_distance\n total_load += route_load\n with open(f\"Survey/vrp-nanostores/vrp-nanostores/food_deserts/outputs/2-e/clust8/route/route_vehicle{vehicle_id}.txt\", \"w\") as file:\n file.write(plan_output)\n file.close()\n print(\"aaa\")\n print('Total cost for all routes: {}m'.format(total_distance))\n print('Total load of all routes: {}'.format(total_load))\n with open(f\"Survey/vrp-nanostores/vrp-nanostores/food_deserts/outputs/2-e/clust8/load_dist_{data['num_vehicles']}vehicles.txt\", \"w\") as file:\n out_file = \"\"\n out_file += str(total_load) + \",\" + str(total_distance)\n file.write(out_file)\n file.close() # OPEN AND ANALYZE LATER WITH PANDAS","def calculate_total_cost(state):\r\n return state.cost()","def evaluate(self, solution: list) -> (float, float):\n start = time() * 1000\n # get the total distance without return\n total_dist = 0\n for idx, node in enumerate(solution[:-1]):\n dist = self.application[solution[idx + 1]][solution[idx]]\n total_dist += dist['weight']\n\n logging.info(f\"Total distance (without return): {total_dist}\")\n\n # add distance between start and end point to complete cycle\n return_distance = self.application[solution[0]][solution[-1]]['weight']\n # logging.info('Distance between start and end: ' + return_distance)\n\n # get distance for full cycle\n distance_with_return = total_dist + return_distance\n logging.info(f\"Total distance (including return): {distance_with_return}\")\n\n return distance_with_return, round(time() * 1000 - start, 3)","def cost(self, route: List[int]) -> float:\n raise NotImplementedError","def evaluate(self, solution, total = 0):\n for objective in self.objectives:\n total = total + objective(solution)\n return total","def file_cost(filename):\r\n return grid_cost(read_grid(filename))","def file_cost(filename):\r\n return grid_cost(read_grid(filename))","def total_cost(self):\n path = self.bidirectional_cpp.getPath()\n return self.bidirectional_cpp.getTotalCost() if len(path) > 0 else None","def finish(outFileName, startTime, ans):\n out_ = open(outFileName, \"w\")\n out_.write(\"%d\\n\" %ans[\"cost\"])\n if len(ans[\"path\"]) > 0:\n s = \"\"\n for n in ans[\"path\"]:\n s += str(n) + \" \"\n s += str(ans[\"path\"][0])\n out_.write(s)\n out_.close()\n print(\"Cost: %d\" %ans[\"cost\"])\n print(\"Finished in %f seconds\" %(time.time()-startTime))","def cost(inventory):\n return inventory.reduce(convert.get_cost)","def print_solution(data, manager, routing, assignment):\r\n total_distance = 0\r\n total_load = 0\r\n # setting the route for each vehicle \r\n file = open('plan_outputGLS.txt','w')\r\n for vehicle_id in range(data['num_vehicles']):\r\n index = routing.Start(vehicle_id)\r\n plan_output = 'Route for vehicle {}:\\n'.format(vehicle_id)\r\n route_distance = 0\r\n route_load = 0\r\n while not routing.IsEnd(index):\r\n node_index = manager.IndexToNode(index)\r\n route_load += data['demands'][node_index]\r\n plan_output += ' {0} Load({1}) -> '.format(node_index, route_load)\r\n previous_index = index\r\n index = assignment.Value(routing.NextVar(index))\r\n route_distance += routing.GetArcCostForVehicle(\r\n previous_index, index, vehicle_id)\r\n plan_output += ' {0} Load({1})\\n'.format(\r\n manager.IndexToNode(index), route_load)\r\n plan_output += 'Distance of the route: {}m\\n'.format(route_distance)\r\n plan_output += 'Load of the route: {}\\n'.format(route_load)\r\n print(plan_output)\r\n file.write(plan_output)\r\n total_distance += route_distance\r\n total_load += route_load\r\n print('Total distance of all routes: {}m'.format(total_distance))\r\n print('Total load of all routes: {}'.format(total_load))\r\n file.write('Total distance of all routes: {}m'.format(total_distance))\r\n file.write('Total load of all routes: {}'.format(total_load))\r\n file.close()","def get_score(self, solution: np.array) -> float:\n score = 0\n for vehicle_count, vehicle_solution in enumerate(solution):\n distances = self.distance_matrix[vehicle_solution[0:-1], vehicle_solution[1:]]\n costs = distances * self.selected_transportation_cost[vehicle_count]\n score += np.sum(costs)\n return score","def local_cost(self) -> Number:\n mu_E = self._payoff_weight_energy\n mu_T = self._payoff_weight_time\n D_loc = SIMULATION_PARAMETERS['LOCAL_CPU_CYCLES']\n F_loc = self.cpu_frequency\n T_loc = D_loc / F_loc\n E_loc = D_loc / self.cpu_effeciency\n return mu_T * T_loc + mu_E * E_loc","def total_cost(self, data, lmbda, convert=False):\n cost = 0.0\n for x, y in data:\n a = self.feedforward(x)\n if convert: y = vectorized_result(y)\n cost += self.cost.fn(a, y)/len(data)\n cost += 0.5*(lmbda/len(data))*sum(\n np.linalg.norm(w)**2 for w in self.weights)\n return cost","def calculate_training_cost(soldier_list: List[Soldier]):\n total_cost = 0.0\n \n for soldier in soldier_list:\n ################################# YOUR CODE HERE #################################\n if soldier.typecode == \"INF\":\n cost = 2.5 * soldier.weapon + 1.0 * soldier.armor\n elif soldier.typecode == \"ARC\":\n cost = 1.5 * soldier.weapon + 3.0 * soldier.armor\n elif soldier.typecode == \"CVL\":\n cost = 4.0 * soldier.weapon + 6.0 * soldier.armor\n if soldier.vitality < 0.35:\n cost *= 0.5\n total_cost += cost\n ##################################################################################\n return total_cost","def _compute_calculate_cost(self):\n for order in self:\n amount_calculate_cost = 0.0\n for line in order.order_line:\n amount_calculate_cost += (line.product_id.standard_price * line.product_uom_qty)\n order.update({\n 'amount_calculate_cost': amount_calculate_cost\n })","def print_solution(self):\n print(f'Objective: {self.solution.ObjectiveValue()}')\n total_distance = 0\n total_load = 0\n max_route_distance = 0\n for vehicle_id in range(self.data['num_vehicles']):\n index = self.routingManager.Start(vehicle_id)\n plan_output = 'Route for vehicle {}:\\n'.format(vehicle_id)\n route_distance = 0\n route_load = 0\n while not self.routingManager.IsEnd(index):\n node_index = self.manager.IndexToNode(index)\n route_load += self.data['demands'][node_index]\n plan_output += ' {0} Load({1}) -> '.format(self.data['names'][node_index], route_load)\n\n previous_index = index\n index = self.solution.Value(self.routingManager.NextVar(index))\n route_distance += self.routingManager.GetArcCostForVehicle(\n previous_index, index, vehicle_id\n )\n print(route_distance)\n\n plan_output += '{0}, Load({1}) \\n '.format(self.data['names'][self.manager.IndexToNode(index)], route_load)\n\n plan_output += 'Distance of the route: {}\\n'.format(route_distance)\n plan_output += 'Load of the route: {}\\n'.format(route_load)\n\n print(plan_output)\n total_distance += route_distance\n total_load += route_load\n\n print('Total distance of all routes: {}km'.format(total_distance))\n print('Total load of all routes: {}'.format(total_load))","def update(self, solution):\n self.heuristic_path = [i for i in self.initial_path if i in solution]\n self.heuristic_cost = self.pathCost(self.heuristic_path)","def save_solution(self, solution_path, file_path):\n node_info = \"\"\n with open(file_path, \"w\") as file:\n file.write(\n \"Strategy: \"\n + str(self.strategy)\n + \"\\n Max Depth: \"\n + str(self.max_depth)\n + \"\\n Depth Increment: \"\n + str(self.depth_increment)\n + \"\\n Pruning: \"\n + str(self.pruning)\n + \"\\n ---SOLUTION---: \"\n )\n for node in solution_path:\n node_info = \"\\n\\n ID: \" + str(node.id)\n if node.last_action != None:\n node_info += \"\\n Action: \" + str(node.last_action)\n node_info += (\n \"\\n Cost: \"\n + str(node.cost)\n + \"\\n Depth: \"\n + str(node.node_depth)\n + \"\\n Heuristic: \"\n + str(node.state.entropy())\n + \"\\n F value: \"\n + str(node.f)\n + \"\\n Node: \"\n + str(node.state.create_md5())\n )\n file.write(node_info)\n node_info = \"\"\n\n file.write(\n \"\\n TOTAL COST: \" + str(solution_path[len(solution_path) - 1].cost)\n )","def print_solution(self, solution_path):\n print(\"---SOLUTION---: \")\n for node in solution_path:\n node.state.plot_cube(\n \"SOLUTION: Node [\" + str(node.id) + \"] at depth \" + str(node.node_depth)\n )\n if node.last_action != None:\n print(\"Next action: \", node.last_action)\n print(\"[\" + str(node.id) + \"] \" + str(node.state.create_md5()))\n\n print(\"\\n TOTAL COST: \", solution_path[len(solution_path) - 1].cost)","def get_expected_cost(self):","def output_cost(run_name):\n\tf = open(toggles.OUTPUT_PATH + run_name + '_sample_cost.csv', 'a')\n\n\tfor p in toggles.CHOSEN_PREDS:\n\t\tpred = Predicate.objects.all().get(pk=p+1)\n\t\tf.write(pred.question.question_text + '\\n')\n\t\tavg_cost = 0.0\n\t\tnum_finished = 0.0\n\n\t\tfor ip in IP_Pair.objects.filter(predicate=pred, status_votes=5):\n\t\t\tcost = ip.num_yes + ip.num_no\n\t\t\tif cost%2 == 1:\n\t\t\t\tavg_cost += cost\n\t\t\t\tnum_finished += 1\n\t\t\tf.write(ip.item.name + ': ' + str(cost) + ', ')\n\n\t\tif num_finished != 0:\n\t\t\tavg_cost = avg_cost/num_finished\n\n\t\tf.write('\\n' + 'avg cost: ' + str(avg_cost) + ', calculated selectivity: ' + str(pred.calculatedSelectivity) + '\\n \\n')\n\tf.write('\\n')\n\tf.close()","def total_cost(self):\n return (self.food_amount + self.local_transport_amount + self.other_expenses +\n self.travel_amount + self.accomodation_amount)","def calculate_cost(self):\n number_collisions = self.get_collisions()\n cs = dict(\n number_collisions=number_collisions,\n cost_collisions=number_collisions\n )\n # sum all costs in one total cost\n cs['cost'] = sum(v for k, v in cs.items() if k.startswith('cost_'))\n\n return cs","def _calculate_costs(self):\n cost = 0\n cost += self._cost_route_fine()\n cost += self._cost_petrol()\n cost += self._cost_wage()\n cost += self._cost_refueling()\n cost += self._cost_caught_by_police()\n cost += self._cost_vehicle_malfunction()\n return cost","def compare_cost(paths_to_results, monetary_scaling_factor, power_scaling_factor, path_to_output):\n scaling_factor = power_scaling_factor / monetary_scaling_factor\n costs = {\n Path(path_to_result).parent.stem: _read_cost(path_to_result, scaling_factor)\n for path_to_result in paths_to_results\n }\n\n pd.Series(costs).rename(index=\"levelised cost of electricity\").to_csv(\n path_to_output,\n index=True,\n header=True,\n float_format=\"%.1f\"\n )","def calculate_cost(self):\n number_collisions = self.get_collisions()\n z = self.agent.get_position()[2]\n cs = dict(\n number_collisions=number_collisions,\n cost_collisions=number_collisions,\n # Drone should not leave valid operation space...\n cost_out_of_range=(1. if z > 2 else 0.)\n )\n # sum all costs in one total cost\n cs['cost'] = min(1, sum(v for k, v in cs.items() if k.startswith('cost_')))\n return cs","def total_cost(self):\r\n return sum(i.line_cost for i in self.orderitem_set.filter(status=self.status)) # pylint: disable=E1101\r","def cost_total(X, cost_weights=(1.0, 1.0, 1.0)):\n return cost_weights[0] * cost_distance(X) + \\\n cost_weights[1] * cost_same_team_by_distance(X) + \\\n cost_weights[2] * cost_previous_neighbour_by_distance(X, normalize=True)","def print_result(self, solution, vehicle_type, if_write):\r\n\r\n result = [['Vehicle_ID', 'Vehicle_type', 'Route', 'Leave_Time', 'Back_Time', 'Work_Time', 'Distance',\r\n 'Load_Volume', 'Wait_Time', 'Fixed_Cost', 'Travel_Cost', 'Total_Cost']]\r\n total_dist = 0\r\n total_cost = 0\r\n for k, veh in enumerate(solution):\r\n if len(veh) == 2:\r\n continue\r\n\r\n if vehicle_type[k] == 2:\r\n trans0 = small_veh[4]\r\n fix0 = small_veh[5]\r\n elif vehicle_type[k] == 3:\r\n trans0 = medium_veh[4]\r\n fix0 = medium_veh[5]\r\n else:\r\n trans0 = large_veh[4]\r\n fix0 = large_veh[5]\r\n\r\n total_cost += fix0\r\n departt = check_violation(veh, vehicle_type[k])[3]\r\n\r\n trvl_dist = 0\r\n veh_load_vol = 0\r\n wait_time = 0\r\n\r\n # get the output format\r\n route = [0] * len(result[0])\r\n route[0] = k + 1 # vehicle name\r\n route[1] = vehicle_type_dict[vehicle_type[k]] # vehicle type\r\n route_ele = []\r\n for ele in veh:\r\n if ele == 0:\r\n route_ele.append(str(ele))\r\n else:\r\n route_ele.append(num_id[ele][0])\r\n route[2] = '-'.join(route_ele) # route\r\n\r\n trvl_dist += (dist_mat[0, veh[1]] + dist_mat[veh[-2], 0])\r\n veh_load_vol += (num_demd[veh[1]][0] * bskt_vol + num_demd[veh[1]][1] * trsf_vol + (num_demd[veh[1]][2] +\r\n num_demd[veh[1]][3]) * milk_vol + num_demd[veh[1]][4] * paper_bskt)\r\n if departt / 60. < 24.:\r\n out_time = int(departt)\r\n else:\r\n out_time = int(departt - 24 * 60)\r\n route[3] = str(out_time // 60) + ':' + str(out_time % 60).zfill(2)\r\n t = departt + time_mat[0, veh[1]] + oprt_t\r\n for i in range(2, len(veh) - 1): # can not wait at the first 2 points\r\n trvl_dist += dist_mat[veh[i - 1], veh[i]]\r\n veh_load_vol += (num_demd[veh[i]][0] * bskt_vol + num_demd[veh[i]][1] * trsf_vol + (num_demd[veh[i]][2] +\r\n num_demd[veh[i]][3]) * milk_vol + num_demd[veh[i]][4] * paper_bskt)\r\n wait_t = num_timez[veh[i]][0] - (t + time_mat[veh[i - 1], veh[i]])\r\n if wait_t > 0 + 1e-5:\r\n # print veh[i-1], veh[i], wait_t\r\n wait_time += wait_t\r\n t = num_timez[veh[i]][0] + oprt_t\r\n else:\r\n t += (time_mat[veh[i - 1], veh[i]] + oprt_t)\r\n if t + time_mat[veh[-2], 0] < 24. * 60:\r\n in_time = int(t + time_mat[veh[-2], 0])\r\n else:\r\n in_time = int(t + time_mat[veh[-2], 0] - 24 * 60)\r\n\r\n route[4] = str(in_time // 60) + ':' + str(in_time % 60).zfill(2) # vehicle back time\r\n route[5] = round((t + time_mat[veh[-2], 0] - departt) / 60., 1)\r\n route[6] = round(trvl_dist / 1000., 2) # total distance\r\n route[7] = veh_load_vol # vehicle load volume\r\n route[8] = wait_time # vehicle wait time\r\n route[9] = fix0 # vehicle fixed cost\r\n route[10] = round(trvl_dist * trans0, 2) # vehicle travel cost\r\n route[11] = route[9] + route[10] # total cost\r\n\r\n total_cost += trvl_dist * trans0\r\n result.append(route)\r\n # print route\r\n total_dist += route[6]\r\n # print 'Last leave time: ', int(t) / 60, ':', int(t) % 60\r\n # print 'total distances: ', route[5]\r\n\r\n if if_write:\r\n run_time = time.strftime(\"%m%d_%H%M\", time.localtime())\r\n with open(r'C:\\Bee\\0Huaat\\Starbucks\\results\\Route_Plan_%s.csv' % run_time, 'w', newline='') as fw:\r\n writer = csv.writer(fw)\r\n for v in result:\r\n writer.writerow(v)\r\n\r\n return round(total_cost, 2)","def calculateCosts(self):\n self.costs = 0\n for house in self.houses:\n if not house.distance == 1000:\n self.costs += house.distance * 9\n for battery in self.batteries:\n self.costs += battery.costs\n return self.costs","def ord_costs(costs, FILE):\r\n list = []\r\n list = sorted(costs, key = get_sum_of_money)\r\n list.reverse()\r\n save_list_json(list, FILE)\r\n return list","def total_cost(self):\n return np.einsum('i->', self.c[self.s])","def get_cost_and_weight_of_knapsack(solution,weight_cost):\r\n cost,weight = 0,0 \r\n for item in solution:\r\n weight += weight_cost[item][0]\r\n cost += weight_cost[item][1]\r\n return cost,weight","def calculate_cost(self):\n costs = {}\n if np.abs(self.agent.get_position()[1]) > self.y_lim:\n costs['cost_outside_bounds'] = 1.\n if self.agent.velocity_violation:\n costs['cost_velocity_violation'] = 1.\n # sum all costs in one total cost\n costs['cost'] = min(1, sum(v for k, v in costs.items() if k.startswith('cost_')))\n return costs","def SumTotalCost():\n\n logs.logger.debug(\"Start to add all amount of Cost objects.\")\n try:\n sumTotal = 0\n for item in GetAllAmountOfCost():\n sumTotal += item\n logs.logger.info(\"Add all amount of Cost objects.\")\n return sumTotal\n except Exception as e:\n logs.logger.error(e, exc_info=True)","def total_cost(self, system=None):\n system = system or self.system()\n if system == 'grid':\n cost = self['system (grid)']['internal system nodal cost']\n else:\n cost = self['system (%s)' % system]['system nodal cost']\n cost = float(cost)\n return cost","def total_cost(self):\n if self.goal:\n return self.goal + (self.community_contribution or 0)\n else:\n return 0","def compute_cost(AL, Y):\n pass","def calc_cost(self):\n cost = 0\n for i,[source, sinks] in enumerate(self.nets):\n self.costs[i] = self.calc_half_perimeter(source, sinks)\n cost += self.costs[i]\n self.cost = cost\n return True","def cost(self, n_batteries, houseList, wireCost, batteryCost):\n\n\t\tcost = 0\n\t\tcost += n_batteries*batteryCost\n\t\tfor house in houseList:\n\t\t\tcost += self.manhattenDistance(house.position, house.batteryAssignment.position)*wireCost\n\t\treturn cost","def total_management_cost(self):\n total = 0\n total += self.output_dict['insurance_usd']\n total += self.output_dict['construction_permitting_usd']\n total += self.output_dict['bonding_usd']\n total += self.output_dict['project_management_usd']\n total += self.output_dict['markup_contingency_usd']\n total += self.output_dict['engineering_usd']\n total += self.output_dict['site_facility_usd']\n return total","def get_total_cost(self):\n total_cost = sum([item.quantity * item.product.price for item in self.orderitem_set.all()])\n return total_cost - total_cost * (self.discount / Decimal('100'))","def compute_cost(AL, Y):\n pass","def print_solution(data, manager, routing, solution):\n # create a file in order to save the solution steps.\n sol_fpath = gbo.create_results_name()\n print(f'Objective: {solution.ObjectiveValue()}')\n max_route_distance = 0\n for vehicle_id in range(data['num_vehicles']):\n index = routing.Start(vehicle_id)\n plan_output = 'Route for vehicle {}:\\n'.format(vehicle_id)\n route_distance = 0\n while not routing.IsEnd(index):\n plan_output += ' {} -> '.format(manager.IndexToNode(index))\n previous_index = index\n index = solution.Value(routing.NextVar(index))\n route_distance += routing.GetArcCostForVehicle(\n previous_index, index, vehicle_id)\n plan_output += '{}\\n'.format(manager.IndexToNode(index))\n plan_output += 'Distance of the route: {}m\\n'.format(route_distance)\n print(plan_output)\n gbo.write_solution_to_file(sol_fpath, plan_output)\n max_route_distance = max(route_distance, max_route_distance)\n print('Maximum of the route distances: {}m'.format(max_route_distance))\n gbo.write_solution_to_file(sol_fpath, \"route distance: \"+str(max_route_distance))","def final_cost(self):\n return self.algorithm_results[-1].final_cost","def print_solution(data, manager, routing, solution):\r\n time_dimension = routing.GetDimensionOrDie('Time')\r\n total_distance = 0\r\n total_load = 0\r\n total_time = 0\r\n for vehicle_id in range(data['num_vehicles']):\r\n index = routing.Start(vehicle_id)\r\n plan_output = 'Route for vehicle {}:\\n'.format(vehicle_id)\r\n route_distance = 0\r\n route_load = 0\r\n while not routing.IsEnd(index):\r\n node_index = manager.IndexToNode(index)\r\n route_load = route_load + data['demands'][node_index]\r\n time_var = time_dimension.CumulVar(index)\r\n plan_output += ' {0} Load({1}) Time({2},{3}) -> '.format(node_index, route_load,\r\n solution.Min(time_var), solution.Max(time_var))\r\n previous_index = index\r\n index = solution.Value(routing.NextVar(index))\r\n route_distance += routing.GetArcCostForVehicle(previous_index, index, vehicle_id)\r\n time_var = time_dimension.CumulVar(index)\r\n plan_output += ' {0} Load({1}) Time({2},{3})\\n'.format(manager.IndexToNode(index), route_load,\r\n solution.Min(time_var), solution.Max(time_var))\r\n plan_output += 'Distance of the route: {}m\\n'.format(route_distance)\r\n plan_output += 'Load of the route: {}\\n'.format(route_load)\r\n plan_output += 'Time of the route: {}min\\n'.format(solution.Min(time_var))\r\n print(plan_output)\r\n total_distance += route_distance\r\n total_load += route_load\r\n total_time += solution.Min(time_var)\r\n print('Total distance of all routes: {}m'.format(total_distance))\r\n print('Total load of all routes: {}'.format(total_load))\r\n print('Total time of all routes: {}min'.format(total_time))","def calculate_costs(self):\n cost_matrix = self.make_cost_matrix()\n \n if self.greedy:\n # Riesen et al., \"Greedy Graph Edit Distance\"\n costs = []\n psi = []\n \n for row in range(self.N):\n phi = self.M\n row_min = sys.maxint\n for column in range(self.N+self.M):\n if column not in psi:\n if cost_matrix[row, column] < row_min:\n row_min = cost_matrix[row, column]\n phi = column\n \n costs.append(row_min)\n if phi < self.M:\n psi.append(phi)\n \n for row in range(self.N, self.N+self.M):\n if (row - self.N) not in psi:\n costs.append(cost_matrix[row, row - self.N])\n else:\n # Riesen & Bunke, \"Approximate graph edit distance computation by means of bipartite graph matching\"\n row_ind, col_ind = optimize.linear_sum_assignment(cost_matrix)\n \n if self.verbose:\n for row, column in (row_ind, col_ind):\n value = cost_matrix[row, column]\n print '%d, %d, %.4f' % (row, column, value)\n \n return row_ind, col_ind, cost_matrix[row_ind, col_ind]","def print_solution(data, manager, routing, assignment):\r\n total_distance = 0\r\n total_load = 0\r\n for vehicle_id in range(data['num_vehicles']):\r\n index = routing.Start(vehicle_id)\r\n plan_output = 'Route for vehicle {}:\\n'.format(vehicle_id+1)\r\n route_distance = 0\r\n route_load = 0\r\n while not routing.IsEnd(index):\r\n node_index = manager.IndexToNode(index)\r\n route_load += data['demands'][node_index]\r\n plan_output += ' {0} Load({1}) -> '.format(node_index, route_load)\r\n previous_index = index\r\n index = assignment.Value(routing.NextVar(index))\r\n route_distance += routing.GetArcCostForVehicle(\r\n previous_index, index, vehicle_id)\r\n plan_output += ' {0} Load({1})\\n'.format(manager.IndexToNode(index),\r\n route_load)\r\n plan_output += 'Distance of the route: {}m\\n'.format(route_distance)\r\n plan_output += 'Load of the route: {}\\n'.format(route_load)\r\n print(plan_output)\r\n total_distance += route_distance\r\n total_load += route_load\r\n print('Total distance of all routes: {}m'.format(total_distance))\r\n print('Total load of all routes: {}'.format(total_load))","def total_cost(self, X, Y, thetas = None):\n \n if thetas == None:\n thetas = self.thetas\n \n J = 0.0\n m = X.shape[0]\n for x, true_indx in zip(X, Y):\n y = np.zeros(self.noutputs)\n y[true_indx] = 1.\n h_theta = self._forward_prop(x, thetas)[-1]\n J += self.cost(h_theta, y)\n \n return np.sum(J)/m","def calculate_cost_for_certificate_batch(self):\n num_inputs = 1\n # output per recipient\n num_outputs = len(self.certificates_to_issue)\n # plus revocation outputs\n num_outputs += sum(1 for c in self.certificates_to_issue.values() if c.revocation_key)\n # plus global revocation, change output, and OP_RETURN\n num_outputs += 3\n self.total = tx_utils.calculate_tx_total(self.tx_cost_constants, num_inputs, num_outputs)\n return self.total","def heuristic_cal(current: list, goal: list) -> int:\n\n current_locations = state_to_locations(current)\n goal_locations = state_to_locations(goal)\n\n h_val = 0 # Tracks the cost of the heuristic function\n for i in range(1, 16):\n h_val += (abs(current_locations[i][0] - goal_locations[i][0]) +\n abs(current_locations[i][1] - goal_locations[i][1]))\n \"\"\" Loops through both lists of locations and adds the Manhattan distance \n of each number to the sum h_val. The range is from 1 to 16 because the \n blank in either state is not taken into account.\"\"\"\n\n return h_val","def out_calc_e_total(target, fp_lst):\r\n e_total_list = []\r\n\r\n for in_node in range(n_hidden): # For each hidden layer node\r\n for out_node in range(n_output): # Find ETotal for weight connected to each output node\r\n e_total = -1 * (target[out_node] - fp_lst[1][out_node]) * fp_lst[1][out_node] * (\r\n 1 - fp_lst[1][out_node]) * fp_lst[0][in_node]\r\n\r\n e_total_list.append(e_total)\r\n\r\n return e_total_list","def sim_average_cost(self, dictionary):\n\t\tif toggles.DEBUG_FLAG:\n\t\t\tprint \"Running: sim_average_cost\"\n\t\tf = open(toggles.OUTPUT_PATH + toggles.RUN_NAME + '_estimated_costs.csv', 'a')\n\n\t\tfor p in toggles.CHOSEN_PREDS:\n\t\t\tpred_cost = 0.0\n\t\t\tpred = Predicate.objects.all().get(pk=p+1)\n\t\t\tf.write(pred.question.question_text + '\\n')\n\n\t\t\t#iterate through to find each ip cost\n\t\t\tfor ip in IP_Pair.objects.filter(predicate=pred):\n\t\t\t\titem_cost = 0.0\n\t\t\t\t# sample toggles.COST_SAMPLES times\n\t\t\t\tfor x in range(toggles.COST_SAMPLES):\n\t\t\t\t\t# running one sampling\n\t\t\t\t\twhile ip.status_votes < toggles.NUM_CERTAIN_VOTES:\n\t\t\t\t\t\t# get the vote\n\t\t\t\t\t\tvalue = choice(dictionary[ip])\n\t\t\t\t\t\tif value == True:\n\t\t\t\t\t\t\tip.value += 1\n\t\t\t\t\t\t\tip.num_yes += 1\n\t\t\t\t\t\telif value == False:\n\t\t\t\t\t\t\tip.value -= 1\n\t\t\t\t\t\t\tip.num_no +=1\n\n\t\t\t\t\t\tip.status_votes += 1\n\n\t\t\t\t\t\t# check if ip is done\n\t\t\t\t\t\tif ip.status_votes == toggles.NUM_CERTAIN_VOTES:\n\t\t\t\t\t\t\t\tif ip.value > 0:\n\t\t\t\t\t\t\t\t\tuncertaintyLevel = btdtr(ip.num_yes+1, ip.num_no+1, toggles.DECISION_THRESHOLD)\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tuncertaintyLevel = btdtr(ip.num_no+1, ip.num_yes+1, toggles.DECISION_THRESHOLD)\n\t\t\t\t\t\t\t\tif uncertaintyLevel < toggles.UNCERTAINTY_THRESHOLD:\n\t\t\t\t\t\t\t\t\titem_cost += (ip.num_yes + ip.num_no)\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tip.status_votes -= 2\n\n\t\t\t\t\t# reset values\n\t\t\t\t\tip.value = 0\n\t\t\t\t\tip.num_yes = 0\n\t\t\t\t\tip.num_no = 0\n\t\t\t\t\tip.status_votes = 0\n\n\t\t\t\titem_cost = item_cost/float(toggles.COST_SAMPLES)\n\t\t\t\tpred_cost += item_cost\n\t\t\t\tf.write(ip.item.name + ': ' + str(item_cost) + \" \")\n\n\t\t\tpred_cost = float(pred_cost)/IP_Pair.objects.filter(predicate=pred).count()\n\t\t\tf.write('\\npredicate average cost: ' + str(pred_cost) + '\\n \\n')\n\t\tf.close()\n\t\tif toggles.DEBUG_FLAG:\n\t\t\tprint \"Wrote File: \" + toggles.OUTPUT_PATH + toggles.RUN_NAME + '_estimated_costs.csv'","def quadratic_cost(output_out, target_out):\r\n total = 0\r\n for target_node in range(len(target_out)): # For each target data set\r\n for output_node in range(len(output_out)): # For each output node\r\n total += (0.5 * (target_out[target_node][output_node] - output_out[output_node])) ** 2\r\n\r\n total = 1 / total\r\n return total","def get_cost(self) -> float:\n return math.e / self.fitness","def compute_fitness(solution):\n\n solution_fitness = 0.0\n\n for index in range(len(solution)):\n waypoint1 = solution[index - 1]\n waypoint2 = solution[index]\n solution_fitness += waypoint_distances[frozenset([waypoint1, waypoint2])]\n\n return solution_fitness","def cost(foods, foods_used):\n cost = 0.00\n for i, count in foods_used.items():\n cost += (foods[i]['serving_cost'] * count)\n return cost","def update_current_sol_and_cost(self,sol=None):\n\n # Update current sol if argument given\n if sol is not None:\n self.current_sol = sol\n \n # Update residual and cost\n try:\n self.residual = self.sketch_reweighted - self.sketch_of_solution(self.current_sol)\n self.current_sol_cost = np.linalg.norm(self.residual)\n except AttributeError: # We are here if self.current_sol does not exist yet\n self.current_sol, self.residual = None, self.sketch_reweighted\n self.current_sol_cost = np.inf","def update_totals(self):\n # Reset counts to 0\n self.total_f = self.total_s = self.total_intra = self.total_mac_regular = self.total_mac_infected = \\\n self.total_mac_activated = self.total_regular_fast = self.total_regular_slow = self.total_infected_fast = \\\n self.total_infected_slow = self.total_activated_fast = self.total_activated_slow = self.total_f_degree = \\\n self.total_s_degree = self.total_activation = 0\n self.total_f_o2 = self.total_s_o2 = 0.0\n\n for node in self.node_list.values():\n # Get values from node\n fast_in_node = node.subpopulations[BACTERIA_FAST]\n slow_in_node = node.subpopulations[BACTERIA_SLOW]\n intra_in_node = node.subpopulations[BACTERIA_INTRACELLULAR]\n reg_mac_in_node = node.subpopulations[MACROPHAGE_REGULAR]\n inf_mac_in_node = node.subpopulations[MACROPHAGE_INFECTED]\n act_mac_in_node = node.subpopulations[MACROPHAGE_ACTIVATED]\n degree = node.degree\n o2_tens = node.oxygen_tension\n # Update relevant totals\n self.total_f += fast_in_node\n self.total_s += slow_in_node\n self.total_intra += intra_in_node\n self.total_mac_regular += reg_mac_in_node\n self.total_mac_infected += inf_mac_in_node\n self.total_mac_activated += act_mac_in_node\n self.total_regular_fast += fast_in_node * reg_mac_in_node\n self.total_regular_slow += slow_in_node * reg_mac_in_node\n self.total_infected_fast += fast_in_node * inf_mac_in_node\n self.total_infected_slow += slow_in_node * inf_mac_in_node\n self.total_activated_fast += fast_in_node * act_mac_in_node\n self.total_activated_slow += slow_in_node * act_mac_in_node\n # TODO - check usage of degree\n self.total_f_degree += fast_in_node * degree\n self.total_s_degree += slow_in_node * degree\n self.total_f_o2 += fast_in_node * (1/o2_tens)\n self.total_s_o2 += slow_in_node * o2_tens\n self.total_activation += reg_mac_in_node * inf_mac_in_node","def dv_update(self, dv_list):\n for line in dv_list:\n line_sep = line.split(',')\n other_name = line_sep[0] + ':' + line_sep[1]\n other_cost = float(line_sep[2])\n self.distance_vector[other_name] = other_cost","def get_cost(self):\n if self.distance == 0:\n for i in range(1, len(self.cities) + 1):\n point1 = self.cities[i - 1]\n point2 = self.cities[i % len(self.cities)]\n self.distance += self.distance_to(point1, point2)\n return self.distance","def compute_tour_cost(self, list_cities: list) -> float:\n cost = 0.0\n n = self.tour_size # Number of cities\n for i in range(n):\n if i + 1 < n:\n cost += list_cities[self.tour_ids[i]].distance(list_cities[self.tour_ids[i + 1]])\n else:\n cost += list_cities[self.tour_ids[i]].distance(list_cities[self.tour_ids[0]])\n\n return cost","def cost(solution):\n cost = 0\n alm_count = 0 # alignment operand/operator count\n fst_len = len(solution[0])\n snd_len = len(solution[1])\n min_len = min(fst_len, snd_len)\n\n for i in range(min_len):\n if solution[0][i] == solution[1][i]:\n alm_count += 1\n\n max_spaces = max(solution[0].count(\" \"), solution[1].count(\" \"))\n cost = ((alm_count * 2.0) + max_spaces) / 3.0\n\n return cost","def cost(self):\n node, path_back = self, []\n cost = 0\n while node:\n path_back.append(node)\n if node.action is not None:\n cost = cost + node.action.cost\n node = node.parent\n # remove one due to root empty node \n #cost = cost-1\n return [cost, list(reversed(path_back))]","def cost(self):\n abs_cost = sum(f['price'] * f['qty'] for f in self.fills)\n return -abs_cost if self.is_ask() else abs_cost","def cost(cost: List[float]) -> List[float]:\n\n data = pd.DataFrame({'cost':np.array(cost).clip(min=0)})\n data['cost'] = data['cost'].rolling(window=data.shape[0],min_periods=1).sum()\n \n return data['cost'].tolist()","def total_cost(path: Path) -> float:\n\t\n\tdistance = calc_total_dist(path)\n\tavg_speed = calc_average_speed(path)\n\t\n\t# Speed is less important, but gets a huge multiplier, because speed and\n\t# \tdistance are in different units. Speed requires a high ratio to have\n\t# \tsimilar amounts of variation.\n\tSPEED_DISTANCE_COST_RATIO = 7865.099\n\t\n\treturn (\n\t\t(distance * 1) +\n\t\t(-avg_speed * SPEED_DISTANCE_COST_RATIO)\n\t)","def calculate_expected_cost(melon_cost, melon_count):\n\n return melon_cost + melon_count","def cost_function(self, config_samples):\n cost = self.work_tracker(config_samples)\n return cost","def __cost_to_goal(self, goal_state):\n cost = 0\n for i in range(len(goal_state) * len(goal_state[0])):\n if(i != 0):\n pos_goal = self.__get_position(i, goal_state)\n pos_current = self.__get_position(i, self.puzzle)\n cost += self.__manhattan(pos_current[0], pos_current[1], pos_goal[0], pos_goal[1])\n return cost","def dp_all(foods, cal_goal, pro_goal, carb_goal, fat_goal):\n costs = init_four_d_array((cal_goal, pro_goal, carb_goal, fat_goal),\n 999999999)\n foods_used = init_four_d_array((cal_goal, pro_goal, carb_goal, fat_goal),\n {})\n\n for i in range(cal_goal):\n for j in range(pro_goal):\n for k in range(carb_goal):\n for l in range(fat_goal):\n for n in range(len(foods)):\n food = foods[n]\n if (int(food['calories']) > i\n or int(food['protein']) > j\n or int(food['carbs']) > k\n or int(food['fat']) > l):\n continue\n if (costs[i - int(food['calories'])]\n [j - int(food['protein'])]\n [k - int(food['carbs'])]\n [l - int(food['fat'])]\n == 999999999):\n prev_cost = 0\n prev_foods_used = {}\n else:\n prev_cost = (macros[i - int(food['calories'])]\n [j - int(food['protein'])]\n [j - int(food['carbs'])]\n [j - int(food['fat'])])\n prev_foods_used = \\\n (foods_used[i - int(food['calories'])]\n [j - int(food['protein'])]\n [k - int(food['carbs'])]\n [l - int(food['fat'])]).copy()\n new_cal = calories(\n foods, prev_foods_used) + food['calories']\n new_pro = protein(\n foods, prev_foods_used) + food['protein']\n new_car = carbs(\n foods, prev_foods_used) + food['protein']\n new_fat = fat(\n foods, prev_foods_used) + food['protein']\n if (costs[i][j] > prev_cost + food['serving_cost']\n and new_cal > i - 20 and new_cal < i + 10\n and new_pro < j + 5 and new_pro < j + 5\n and new_car < j + 5 and new_car < j + 5\n and new_fat < j + 5 and new_fat < j + 5):\n costs[i][j][k][l] = prev_cost + \\\n food['serving_cost']\n try:\n prev_foods_used[n] += 1\n except KeyError:\n prev_foods_used[n] = 1\n foods_used[i][j][k][l] = prev_foods_used\n return foods_used[cal_goal - 1][pro_goal - 1][carb_goal - 1][fat_goal - 1]","def cost(self):\n\t\treturn self.g + self.h","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE ***\"\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n n = Directions.NORTH\n e = Directions.EAST\n\n result = []\n qu = util.PriorityQueue()\n visited = set([])\n current = (problem.getStartState(), \"\", 0)\n qu.update(current, 0)\n costs = {}\n parents = {}\n parents[problem.getStartState()] = (problem.getStartState(), \"\")\n\n while not qu.isEmpty():\n cost, current= qu.pop()\n visited.add(current[0])\n\n if problem.isGoalState(current[0]):\n result = current[0]\n break\n\n for each in problem.getSuccessors(current[0]):\n if each[0] not in visited:\n qu.update(each, cost+each[2])\n if each[0] not in costs:\n costs[each[0]] = cost+each[2]\n parents[each[0]] = (current[0], each[1])\n elif costs[each[0]] > cost+each[2]:\n costs[each[0]] = cost + each[2]\n parents[each[0]] = (current[0], each[1])\n\n path = []\n while parents[result][0] != result:\n path.append(parents[result][1])\n result = parents[result][0]\n\n path.reverse()\n result = []\n for each in path:\n if each == \"South\":\n result.append(s)\n elif each == \"West\":\n result.append(w)\n elif each == \"North\":\n result.append(n)\n elif each == \"East\":\n result.append(e)\n\n return result\n util.raiseNotDefined()","def get_cost_updates(self):\n\n y = self.get_hidden_values()\n z = self.get_reconstructed_input(y)\n\n L = T.sum((self.x-z)**2, axis=1)\n\n cost = T.mean(L)\n\n return cost","def cost(self, output, labels, weights):\n raise NotImplementedError('Must be overridden by concrete subclass')","def get_hcost(self):\n hvcost = self.get_hvcost()\n dcost = self.get_dcost()\n hcost = hvcost + dcost\n return hcost","def execution_cost(self):\n #TODO: Compute execution cost\n total_cost = 0\n for res_cfg in self.resource_configurations:\n mapped_tasks = list(filter(lambda x: x.resource_schedule.config == res_cfg, self.schedule_mapping_list))\n makespan_res = SchedulePlan._makespan(mapped_tasks)\n total_cost += makespan_res * res_cfg.cost_hour_usd\n return total_cost","def get_sol(self):","def cost_function(self, element):\n return self.maze.cost(element)","def total_cost(self, J_content, J_style, alpha=10, beta=40):\n\n J_total_cost = alpha * J_content + beta * J_style\n\n return J_total_cost","def cost(self):\n return self._cost","def cost(self):\n return self._cost","def route_cost(self, route):\n total_weight = 0\n c = 0\n start = route[0]\n for end in route[1:]:\n y = float(self.stars[start][end]['weight']) - c\n t = total_weight + y\n c = (t - total_weight) - y\n\n total_weight = t\n\n start = end\n return total_weight","def run_solution1_simple(self):\n fuel_sum = 0\n for n in self.data:\n fuel_sum += self.calculate_fuel(n)\n return fuel_sum","def write_solutions_to_files(\n solutions: List[Solution], path: Path, folder_name: str = \"CodeWars\"\n) -> None:\n stat = {}\n path = path / folder_name\n for solution in solutions:\n if solution.kyu in stat:\n stat[solution.kyu] += 1\n else:\n stat[solution.kyu] = 1\n\n path_to_solution = get_dir(solution, path)\n path_to_solution.mkdir(parents=True, exist_ok=True)\n\n create_file(\n path_to_solution / f\"main{EXTENSIONS[solution.language]}\", solution.solution\n )\n\n create_file(path_to_solution / \"README.md\", f\"Link: {solution.link}\")\n\n kuy_stat = \"\\n\".join([f\":star: {x}: {stat[x]} :star:\" for x in sorted(stat)])\n create_file(\n path / \"README.md\",\n f\"Total: {sum([stat[x] for x in stat])}\\n\" f\"Detail statistic:\\n{kuy_stat}\",\n )","def tablecost(self):\n subtotal_getter = operator.attrgetter(\"subtotal\")\n\n cost = 0.0\n\n cost += sum(map(subtotal_getter, self.materials))\n cost += sum(map(subtotal_getter, self.processes))\n cost += sum(map(subtotal_getter, self.fasteners))\n cost += sum(map(subtotal_getter, self.toolings))\n\n return cost","def print_solution(manager, routing, solution):\n print('Objective: {} miles'.format(solution.ObjectiveValue()))\n index = routing.Start(0)\n plan_output = 'Route for vehicle 0:\\n'\n route_distance = 0\n while not routing.IsEnd(index):\n plan_output += ' {} ->'.format(manager.IndexToNode(index))\n previous_index = index\n index = solution.Value(routing.NextVar(index))\n route_distance += routing.GetArcCostForVehicle(previous_index, index, 0)\n plan_output += ' {}\\n'.format(manager.IndexToNode(index))\n print(plan_output)\n plan_output += 'Route distance: {}miles\\n'.format(route_distance)","def print_solution(manager, routing, solution):\n print('Objective: {} miles'.format(solution.ObjectiveValue()))\n index = routing.Start(0)\n plan_output = 'Route for vehicle 0:\\n'\n route_distance = 0\n while not routing.IsEnd(index):\n plan_output += ' {} ->'.format(manager.IndexToNode(index))\n previous_index = index\n index = solution.Value(routing.NextVar(index))\n route_distance += routing.GetArcCostForVehicle(previous_index, index, 0)\n plan_output += ' {}\\n'.format(manager.IndexToNode(index))\n print(plan_output)\n plan_output += 'Route distance: {}miles\\n'.format(route_distance)","def twoCitySchedCost(self, costs: List[List[int]]) -> int:\n def abs_diff_compare(x=[1,2], y=[3,4]):\n x1=x[0]-x[1] if x[0]>=x[1] else x[1]-x[0]\n y1=y[0]-y[1] if y[0]>=y[1] else y[1]-x[0]\n return x1 if x1>y1 else y1\n save_costs=costs\n costs.sort(reverse=True, key=abs_diff_compare)\n print(costs)\n nA=0\n nB=0\n tc=0\n num_people=len(costs)\n max_ppl=num_people//2\n \n for x in costs:\n if nA< max_ppl and nB< max_ppl :\n if x[0] <x[1]:\n nA+=1\n tc+=x[0]\n else:\n nB+=1\n tc+=x[1]\n elif nA< max_ppl:\n nA+=1\n tc+=x[0]\n elif nB< max_ppl:\n nB+=1\n tc+=x[1]\n \n \n return tc","def evaluate(G, path, home_idxs, verbose=False):\n dropoffs = assign_dropoffs(G, path, home_idxs)\n cost, msg = cost_of_solution(G, path, dropoffs, shortest=all_pairs_dists)\n if verbose:\n print(msg)\n\n return cost","def totalValue(self):\n\n\t\tvalue = 0\n\t\tfor bottle in self.bottles:\n\t\t\tvalue += bottle.inflatedCost\n\n\t\treturn value","def rate(way):\n cost = 0\n for i in range(len(way)-1):\n cost += DISTANCES[way[i]][way[i+1]]\n return cost","def calculate_cost(self, **kwargs):\n costs = {}\n if np.abs(self.agent.get_position()[0]) > self.x_lim:\n costs['cost_outside_bounds'] = 1.\n # sum all costs in one total cost\n costs['cost'] = min(1, sum(v for k, v in costs.items() if k.startswith('cost_')))\n\n return costs","def computeAssignments(solution, h, data, sumW, checkers, hini=None):\n minHours = data[\"minHours\"]\n hours = data[\"hours\"]\n z = solution[\"z\"]\n w = solution[\"w\"]\n\n mustWork = []\n canWork = []\n\n # sort nurses, first by those who work\n sorted_nurses = sorted(range(data[\"nNurses\"]), key=lambda n: solution[\"z\"][n], reverse=True)\n # print(solution[\"z\"])\n # print(sorted_nurses)\n # print(\"\")\n\n # for each nurse\n for n in sorted_nurses:\n\n # canWork Check-------------------------------\n canWork_check = checkIfCanWork_fast(solution, h, n, data, sumW, checkers=checkers, hini=hini)\n if canWork_check:\n\n\n mustWork_check = checkIfMustWork_fast(solution, h, n, data, sumW, True, checkers, hini)\n if mustWork_check:\n mustWork.append(n)\n else: \n canWork.append(n)\n\n # # mustWork Check-------------------------------\n # # avoid repeating canWork_check\n # mustWork_check = checkIfMustWork_fast(solution, h, n, data, sumW, canWork_check, checkers, hini)\n # if mustWork_check:\n # mustWork.append(n)\n # else:\n \n return mustWork, canWork"],"string":"[\n \"def print_and_save_solution(data, manager, routing, assignment):\\n total_distance = 0\\n total_load = 0\\n routes = []\\n for vehicle_id in range(data['num_vehicles']):\\n route = []\\n index = routing.Start(vehicle_id)\\n plan_output = 'Route for vehicle {}:\\\\n'.format(vehicle_id)\\n route_distance = 0\\n route_load = 0\\n while not routing.IsEnd(index):\\n node_index = manager.IndexToNode(index)\\n route_load += data['demands'][node_index]\\n plan_output += ' {0} Load({1}) -> '.format(node_index, route_load)\\n previous_index = index\\n index = assignment.Value(routing.NextVar(index))\\n route_distance += routing.GetArcCostForVehicle(\\n previous_index, index, vehicle_id)\\n point = data['all_points'][node_index]\\n point['load'] = route_load\\n route.append(point)\\n plan_output += ' {0} Load({1})\\\\n'.format(manager.IndexToNode(index),\\n route_load)\\n plan_output += 'Distance of the route: {}m\\\\n'.format(route_distance)\\n plan_output += 'Load of the route: {}\\\\n'.format(route_load)\\n print(plan_output)\\n total_distance += route_distance\\n total_load += route_load\\n if route_load > 0:\\n routes.append({\\n 'stops': route,\\n 'distance': route_distance,\\n 'load': route_load,\\n 'number_of_stops': len(route)\\n })\\n print('Total distance of all routes: {}m'.format(total_distance))\\n print('Total load of all routes: {}'.format(total_load))\\n with open('./results/capacity_{}_{}.json'.format(DRONES_CAPACITY, MAX_POINT_DEMAND), 'w') as f:\\n simplejson.dump({\\n 'routes': routes,\\n 'total_load': total_load,\\n 'total_distance': total_distance,\\n 'number_of_drones_used': len(routes),\\n 'total_numer_of_stops': sum([x['number_of_stops'] for x in routes])\\n }, f)\",\n \"def calculateCost(self,sol,weights):\\n\\t\\treturn sum([x.value*y if x != None else 0 \\\\\\n\\t\\t\\t\\t\\tfor x,y in zip(sol,weights)])\",\n \"def add_cost(costs, cost, FILE):\\r\\n costs.append(cost)\\r\\n save_list_json(costs, FILE)\\r\\n return costs\",\n \"def total_cost_2D(self, final_list):\\n total_cost = 0\\n for i in range(len(final_list) - 1):\\n temp = self.pairwise_distance(final_list[i], final_list[i + 1])\\n total_cost = total_cost + temp\\n print(\\\"Total distance: \\\" + str(total_cost))\",\n \"def cost(self) -> float:\",\n \"def calculate_total_cost(state):\\n pass\",\n \"def print_solution(data, manager, routing, assignment):\\n total_distance = 0\\n total_load = 0\\n for vehicle_id in range(data['num_vehicles']):\\n index = routing.Start(vehicle_id)\\n plan_output = 'Route for vehicle {}:\\\\n'.format(vehicle_id)\\n route_distance = 0\\n route_load = 0\\n while not routing.IsEnd(index):\\n node_index = manager.IndexToNode(index)\\n route_load += data['demands'][node_index]\\n plan_output += ' {0} Load({1}) -> '.format(node_index, route_load)\\n previous_index = index\\n index = assignment.Value(routing.NextVar(index))\\n route_distance += routing.GetArcCostForVehicle(\\n previous_index, index, vehicle_id)\\n plan_output += ' {0} Load({1})\\\\n'.format(manager.IndexToNode(index),\\n route_load)\\n plan_output += 'Distance of the route: {}m\\\\n'.format(route_distance)\\n plan_output += 'Load of the route: {}\\\\n'.format(route_load)\\n # print(plan_output)\\n total_distance += route_distance\\n total_load += route_load\\n with open(f\\\"Survey/vrp-nanostores/vrp-nanostores/food_deserts/outputs/2-e/clust8/route/route_vehicle{vehicle_id}.txt\\\", \\\"w\\\") as file:\\n file.write(plan_output)\\n file.close()\\n print(\\\"aaa\\\")\\n print('Total cost for all routes: {}m'.format(total_distance))\\n print('Total load of all routes: {}'.format(total_load))\\n with open(f\\\"Survey/vrp-nanostores/vrp-nanostores/food_deserts/outputs/2-e/clust8/load_dist_{data['num_vehicles']}vehicles.txt\\\", \\\"w\\\") as file:\\n out_file = \\\"\\\"\\n out_file += str(total_load) + \\\",\\\" + str(total_distance)\\n file.write(out_file)\\n file.close() # OPEN AND ANALYZE LATER WITH PANDAS\",\n \"def calculate_total_cost(state):\\r\\n return state.cost()\",\n \"def evaluate(self, solution: list) -> (float, float):\\n start = time() * 1000\\n # get the total distance without return\\n total_dist = 0\\n for idx, node in enumerate(solution[:-1]):\\n dist = self.application[solution[idx + 1]][solution[idx]]\\n total_dist += dist['weight']\\n\\n logging.info(f\\\"Total distance (without return): {total_dist}\\\")\\n\\n # add distance between start and end point to complete cycle\\n return_distance = self.application[solution[0]][solution[-1]]['weight']\\n # logging.info('Distance between start and end: ' + return_distance)\\n\\n # get distance for full cycle\\n distance_with_return = total_dist + return_distance\\n logging.info(f\\\"Total distance (including return): {distance_with_return}\\\")\\n\\n return distance_with_return, round(time() * 1000 - start, 3)\",\n \"def cost(self, route: List[int]) -> float:\\n raise NotImplementedError\",\n \"def evaluate(self, solution, total = 0):\\n for objective in self.objectives:\\n total = total + objective(solution)\\n return total\",\n \"def file_cost(filename):\\r\\n return grid_cost(read_grid(filename))\",\n \"def file_cost(filename):\\r\\n return grid_cost(read_grid(filename))\",\n \"def total_cost(self):\\n path = self.bidirectional_cpp.getPath()\\n return self.bidirectional_cpp.getTotalCost() if len(path) > 0 else None\",\n \"def finish(outFileName, startTime, ans):\\n out_ = open(outFileName, \\\"w\\\")\\n out_.write(\\\"%d\\\\n\\\" %ans[\\\"cost\\\"])\\n if len(ans[\\\"path\\\"]) > 0:\\n s = \\\"\\\"\\n for n in ans[\\\"path\\\"]:\\n s += str(n) + \\\" \\\"\\n s += str(ans[\\\"path\\\"][0])\\n out_.write(s)\\n out_.close()\\n print(\\\"Cost: %d\\\" %ans[\\\"cost\\\"])\\n print(\\\"Finished in %f seconds\\\" %(time.time()-startTime))\",\n \"def cost(inventory):\\n return inventory.reduce(convert.get_cost)\",\n \"def print_solution(data, manager, routing, assignment):\\r\\n total_distance = 0\\r\\n total_load = 0\\r\\n # setting the route for each vehicle \\r\\n file = open('plan_outputGLS.txt','w')\\r\\n for vehicle_id in range(data['num_vehicles']):\\r\\n index = routing.Start(vehicle_id)\\r\\n plan_output = 'Route for vehicle {}:\\\\n'.format(vehicle_id)\\r\\n route_distance = 0\\r\\n route_load = 0\\r\\n while not routing.IsEnd(index):\\r\\n node_index = manager.IndexToNode(index)\\r\\n route_load += data['demands'][node_index]\\r\\n plan_output += ' {0} Load({1}) -> '.format(node_index, route_load)\\r\\n previous_index = index\\r\\n index = assignment.Value(routing.NextVar(index))\\r\\n route_distance += routing.GetArcCostForVehicle(\\r\\n previous_index, index, vehicle_id)\\r\\n plan_output += ' {0} Load({1})\\\\n'.format(\\r\\n manager.IndexToNode(index), route_load)\\r\\n plan_output += 'Distance of the route: {}m\\\\n'.format(route_distance)\\r\\n plan_output += 'Load of the route: {}\\\\n'.format(route_load)\\r\\n print(plan_output)\\r\\n file.write(plan_output)\\r\\n total_distance += route_distance\\r\\n total_load += route_load\\r\\n print('Total distance of all routes: {}m'.format(total_distance))\\r\\n print('Total load of all routes: {}'.format(total_load))\\r\\n file.write('Total distance of all routes: {}m'.format(total_distance))\\r\\n file.write('Total load of all routes: {}'.format(total_load))\\r\\n file.close()\",\n \"def get_score(self, solution: np.array) -> float:\\n score = 0\\n for vehicle_count, vehicle_solution in enumerate(solution):\\n distances = self.distance_matrix[vehicle_solution[0:-1], vehicle_solution[1:]]\\n costs = distances * self.selected_transportation_cost[vehicle_count]\\n score += np.sum(costs)\\n return score\",\n \"def local_cost(self) -> Number:\\n mu_E = self._payoff_weight_energy\\n mu_T = self._payoff_weight_time\\n D_loc = SIMULATION_PARAMETERS['LOCAL_CPU_CYCLES']\\n F_loc = self.cpu_frequency\\n T_loc = D_loc / F_loc\\n E_loc = D_loc / self.cpu_effeciency\\n return mu_T * T_loc + mu_E * E_loc\",\n \"def total_cost(self, data, lmbda, convert=False):\\n cost = 0.0\\n for x, y in data:\\n a = self.feedforward(x)\\n if convert: y = vectorized_result(y)\\n cost += self.cost.fn(a, y)/len(data)\\n cost += 0.5*(lmbda/len(data))*sum(\\n np.linalg.norm(w)**2 for w in self.weights)\\n return cost\",\n \"def calculate_training_cost(soldier_list: List[Soldier]):\\n total_cost = 0.0\\n \\n for soldier in soldier_list:\\n ################################# YOUR CODE HERE #################################\\n if soldier.typecode == \\\"INF\\\":\\n cost = 2.5 * soldier.weapon + 1.0 * soldier.armor\\n elif soldier.typecode == \\\"ARC\\\":\\n cost = 1.5 * soldier.weapon + 3.0 * soldier.armor\\n elif soldier.typecode == \\\"CVL\\\":\\n cost = 4.0 * soldier.weapon + 6.0 * soldier.armor\\n if soldier.vitality < 0.35:\\n cost *= 0.5\\n total_cost += cost\\n ##################################################################################\\n return total_cost\",\n \"def _compute_calculate_cost(self):\\n for order in self:\\n amount_calculate_cost = 0.0\\n for line in order.order_line:\\n amount_calculate_cost += (line.product_id.standard_price * line.product_uom_qty)\\n order.update({\\n 'amount_calculate_cost': amount_calculate_cost\\n })\",\n \"def print_solution(self):\\n print(f'Objective: {self.solution.ObjectiveValue()}')\\n total_distance = 0\\n total_load = 0\\n max_route_distance = 0\\n for vehicle_id in range(self.data['num_vehicles']):\\n index = self.routingManager.Start(vehicle_id)\\n plan_output = 'Route for vehicle {}:\\\\n'.format(vehicle_id)\\n route_distance = 0\\n route_load = 0\\n while not self.routingManager.IsEnd(index):\\n node_index = self.manager.IndexToNode(index)\\n route_load += self.data['demands'][node_index]\\n plan_output += ' {0} Load({1}) -> '.format(self.data['names'][node_index], route_load)\\n\\n previous_index = index\\n index = self.solution.Value(self.routingManager.NextVar(index))\\n route_distance += self.routingManager.GetArcCostForVehicle(\\n previous_index, index, vehicle_id\\n )\\n print(route_distance)\\n\\n plan_output += '{0}, Load({1}) \\\\n '.format(self.data['names'][self.manager.IndexToNode(index)], route_load)\\n\\n plan_output += 'Distance of the route: {}\\\\n'.format(route_distance)\\n plan_output += 'Load of the route: {}\\\\n'.format(route_load)\\n\\n print(plan_output)\\n total_distance += route_distance\\n total_load += route_load\\n\\n print('Total distance of all routes: {}km'.format(total_distance))\\n print('Total load of all routes: {}'.format(total_load))\",\n \"def update(self, solution):\\n self.heuristic_path = [i for i in self.initial_path if i in solution]\\n self.heuristic_cost = self.pathCost(self.heuristic_path)\",\n \"def save_solution(self, solution_path, file_path):\\n node_info = \\\"\\\"\\n with open(file_path, \\\"w\\\") as file:\\n file.write(\\n \\\"Strategy: \\\"\\n + str(self.strategy)\\n + \\\"\\\\n Max Depth: \\\"\\n + str(self.max_depth)\\n + \\\"\\\\n Depth Increment: \\\"\\n + str(self.depth_increment)\\n + \\\"\\\\n Pruning: \\\"\\n + str(self.pruning)\\n + \\\"\\\\n ---SOLUTION---: \\\"\\n )\\n for node in solution_path:\\n node_info = \\\"\\\\n\\\\n ID: \\\" + str(node.id)\\n if node.last_action != None:\\n node_info += \\\"\\\\n Action: \\\" + str(node.last_action)\\n node_info += (\\n \\\"\\\\n Cost: \\\"\\n + str(node.cost)\\n + \\\"\\\\n Depth: \\\"\\n + str(node.node_depth)\\n + \\\"\\\\n Heuristic: \\\"\\n + str(node.state.entropy())\\n + \\\"\\\\n F value: \\\"\\n + str(node.f)\\n + \\\"\\\\n Node: \\\"\\n + str(node.state.create_md5())\\n )\\n file.write(node_info)\\n node_info = \\\"\\\"\\n\\n file.write(\\n \\\"\\\\n TOTAL COST: \\\" + str(solution_path[len(solution_path) - 1].cost)\\n )\",\n \"def print_solution(self, solution_path):\\n print(\\\"---SOLUTION---: \\\")\\n for node in solution_path:\\n node.state.plot_cube(\\n \\\"SOLUTION: Node [\\\" + str(node.id) + \\\"] at depth \\\" + str(node.node_depth)\\n )\\n if node.last_action != None:\\n print(\\\"Next action: \\\", node.last_action)\\n print(\\\"[\\\" + str(node.id) + \\\"] \\\" + str(node.state.create_md5()))\\n\\n print(\\\"\\\\n TOTAL COST: \\\", solution_path[len(solution_path) - 1].cost)\",\n \"def get_expected_cost(self):\",\n \"def output_cost(run_name):\\n\\tf = open(toggles.OUTPUT_PATH + run_name + '_sample_cost.csv', 'a')\\n\\n\\tfor p in toggles.CHOSEN_PREDS:\\n\\t\\tpred = Predicate.objects.all().get(pk=p+1)\\n\\t\\tf.write(pred.question.question_text + '\\\\n')\\n\\t\\tavg_cost = 0.0\\n\\t\\tnum_finished = 0.0\\n\\n\\t\\tfor ip in IP_Pair.objects.filter(predicate=pred, status_votes=5):\\n\\t\\t\\tcost = ip.num_yes + ip.num_no\\n\\t\\t\\tif cost%2 == 1:\\n\\t\\t\\t\\tavg_cost += cost\\n\\t\\t\\t\\tnum_finished += 1\\n\\t\\t\\tf.write(ip.item.name + ': ' + str(cost) + ', ')\\n\\n\\t\\tif num_finished != 0:\\n\\t\\t\\tavg_cost = avg_cost/num_finished\\n\\n\\t\\tf.write('\\\\n' + 'avg cost: ' + str(avg_cost) + ', calculated selectivity: ' + str(pred.calculatedSelectivity) + '\\\\n \\\\n')\\n\\tf.write('\\\\n')\\n\\tf.close()\",\n \"def total_cost(self):\\n return (self.food_amount + self.local_transport_amount + self.other_expenses +\\n self.travel_amount + self.accomodation_amount)\",\n \"def calculate_cost(self):\\n number_collisions = self.get_collisions()\\n cs = dict(\\n number_collisions=number_collisions,\\n cost_collisions=number_collisions\\n )\\n # sum all costs in one total cost\\n cs['cost'] = sum(v for k, v in cs.items() if k.startswith('cost_'))\\n\\n return cs\",\n \"def _calculate_costs(self):\\n cost = 0\\n cost += self._cost_route_fine()\\n cost += self._cost_petrol()\\n cost += self._cost_wage()\\n cost += self._cost_refueling()\\n cost += self._cost_caught_by_police()\\n cost += self._cost_vehicle_malfunction()\\n return cost\",\n \"def compare_cost(paths_to_results, monetary_scaling_factor, power_scaling_factor, path_to_output):\\n scaling_factor = power_scaling_factor / monetary_scaling_factor\\n costs = {\\n Path(path_to_result).parent.stem: _read_cost(path_to_result, scaling_factor)\\n for path_to_result in paths_to_results\\n }\\n\\n pd.Series(costs).rename(index=\\\"levelised cost of electricity\\\").to_csv(\\n path_to_output,\\n index=True,\\n header=True,\\n float_format=\\\"%.1f\\\"\\n )\",\n \"def calculate_cost(self):\\n number_collisions = self.get_collisions()\\n z = self.agent.get_position()[2]\\n cs = dict(\\n number_collisions=number_collisions,\\n cost_collisions=number_collisions,\\n # Drone should not leave valid operation space...\\n cost_out_of_range=(1. if z > 2 else 0.)\\n )\\n # sum all costs in one total cost\\n cs['cost'] = min(1, sum(v for k, v in cs.items() if k.startswith('cost_')))\\n return cs\",\n \"def total_cost(self):\\r\\n return sum(i.line_cost for i in self.orderitem_set.filter(status=self.status)) # pylint: disable=E1101\\r\",\n \"def cost_total(X, cost_weights=(1.0, 1.0, 1.0)):\\n return cost_weights[0] * cost_distance(X) + \\\\\\n cost_weights[1] * cost_same_team_by_distance(X) + \\\\\\n cost_weights[2] * cost_previous_neighbour_by_distance(X, normalize=True)\",\n \"def print_result(self, solution, vehicle_type, if_write):\\r\\n\\r\\n result = [['Vehicle_ID', 'Vehicle_type', 'Route', 'Leave_Time', 'Back_Time', 'Work_Time', 'Distance',\\r\\n 'Load_Volume', 'Wait_Time', 'Fixed_Cost', 'Travel_Cost', 'Total_Cost']]\\r\\n total_dist = 0\\r\\n total_cost = 0\\r\\n for k, veh in enumerate(solution):\\r\\n if len(veh) == 2:\\r\\n continue\\r\\n\\r\\n if vehicle_type[k] == 2:\\r\\n trans0 = small_veh[4]\\r\\n fix0 = small_veh[5]\\r\\n elif vehicle_type[k] == 3:\\r\\n trans0 = medium_veh[4]\\r\\n fix0 = medium_veh[5]\\r\\n else:\\r\\n trans0 = large_veh[4]\\r\\n fix0 = large_veh[5]\\r\\n\\r\\n total_cost += fix0\\r\\n departt = check_violation(veh, vehicle_type[k])[3]\\r\\n\\r\\n trvl_dist = 0\\r\\n veh_load_vol = 0\\r\\n wait_time = 0\\r\\n\\r\\n # get the output format\\r\\n route = [0] * len(result[0])\\r\\n route[0] = k + 1 # vehicle name\\r\\n route[1] = vehicle_type_dict[vehicle_type[k]] # vehicle type\\r\\n route_ele = []\\r\\n for ele in veh:\\r\\n if ele == 0:\\r\\n route_ele.append(str(ele))\\r\\n else:\\r\\n route_ele.append(num_id[ele][0])\\r\\n route[2] = '-'.join(route_ele) # route\\r\\n\\r\\n trvl_dist += (dist_mat[0, veh[1]] + dist_mat[veh[-2], 0])\\r\\n veh_load_vol += (num_demd[veh[1]][0] * bskt_vol + num_demd[veh[1]][1] * trsf_vol + (num_demd[veh[1]][2] +\\r\\n num_demd[veh[1]][3]) * milk_vol + num_demd[veh[1]][4] * paper_bskt)\\r\\n if departt / 60. < 24.:\\r\\n out_time = int(departt)\\r\\n else:\\r\\n out_time = int(departt - 24 * 60)\\r\\n route[3] = str(out_time // 60) + ':' + str(out_time % 60).zfill(2)\\r\\n t = departt + time_mat[0, veh[1]] + oprt_t\\r\\n for i in range(2, len(veh) - 1): # can not wait at the first 2 points\\r\\n trvl_dist += dist_mat[veh[i - 1], veh[i]]\\r\\n veh_load_vol += (num_demd[veh[i]][0] * bskt_vol + num_demd[veh[i]][1] * trsf_vol + (num_demd[veh[i]][2] +\\r\\n num_demd[veh[i]][3]) * milk_vol + num_demd[veh[i]][4] * paper_bskt)\\r\\n wait_t = num_timez[veh[i]][0] - (t + time_mat[veh[i - 1], veh[i]])\\r\\n if wait_t > 0 + 1e-5:\\r\\n # print veh[i-1], veh[i], wait_t\\r\\n wait_time += wait_t\\r\\n t = num_timez[veh[i]][0] + oprt_t\\r\\n else:\\r\\n t += (time_mat[veh[i - 1], veh[i]] + oprt_t)\\r\\n if t + time_mat[veh[-2], 0] < 24. * 60:\\r\\n in_time = int(t + time_mat[veh[-2], 0])\\r\\n else:\\r\\n in_time = int(t + time_mat[veh[-2], 0] - 24 * 60)\\r\\n\\r\\n route[4] = str(in_time // 60) + ':' + str(in_time % 60).zfill(2) # vehicle back time\\r\\n route[5] = round((t + time_mat[veh[-2], 0] - departt) / 60., 1)\\r\\n route[6] = round(trvl_dist / 1000., 2) # total distance\\r\\n route[7] = veh_load_vol # vehicle load volume\\r\\n route[8] = wait_time # vehicle wait time\\r\\n route[9] = fix0 # vehicle fixed cost\\r\\n route[10] = round(trvl_dist * trans0, 2) # vehicle travel cost\\r\\n route[11] = route[9] + route[10] # total cost\\r\\n\\r\\n total_cost += trvl_dist * trans0\\r\\n result.append(route)\\r\\n # print route\\r\\n total_dist += route[6]\\r\\n # print 'Last leave time: ', int(t) / 60, ':', int(t) % 60\\r\\n # print 'total distances: ', route[5]\\r\\n\\r\\n if if_write:\\r\\n run_time = time.strftime(\\\"%m%d_%H%M\\\", time.localtime())\\r\\n with open(r'C:\\\\Bee\\\\0Huaat\\\\Starbucks\\\\results\\\\Route_Plan_%s.csv' % run_time, 'w', newline='') as fw:\\r\\n writer = csv.writer(fw)\\r\\n for v in result:\\r\\n writer.writerow(v)\\r\\n\\r\\n return round(total_cost, 2)\",\n \"def calculateCosts(self):\\n self.costs = 0\\n for house in self.houses:\\n if not house.distance == 1000:\\n self.costs += house.distance * 9\\n for battery in self.batteries:\\n self.costs += battery.costs\\n return self.costs\",\n \"def ord_costs(costs, FILE):\\r\\n list = []\\r\\n list = sorted(costs, key = get_sum_of_money)\\r\\n list.reverse()\\r\\n save_list_json(list, FILE)\\r\\n return list\",\n \"def total_cost(self):\\n return np.einsum('i->', self.c[self.s])\",\n \"def get_cost_and_weight_of_knapsack(solution,weight_cost):\\r\\n cost,weight = 0,0 \\r\\n for item in solution:\\r\\n weight += weight_cost[item][0]\\r\\n cost += weight_cost[item][1]\\r\\n return cost,weight\",\n \"def calculate_cost(self):\\n costs = {}\\n if np.abs(self.agent.get_position()[1]) > self.y_lim:\\n costs['cost_outside_bounds'] = 1.\\n if self.agent.velocity_violation:\\n costs['cost_velocity_violation'] = 1.\\n # sum all costs in one total cost\\n costs['cost'] = min(1, sum(v for k, v in costs.items() if k.startswith('cost_')))\\n return costs\",\n \"def SumTotalCost():\\n\\n logs.logger.debug(\\\"Start to add all amount of Cost objects.\\\")\\n try:\\n sumTotal = 0\\n for item in GetAllAmountOfCost():\\n sumTotal += item\\n logs.logger.info(\\\"Add all amount of Cost objects.\\\")\\n return sumTotal\\n except Exception as e:\\n logs.logger.error(e, exc_info=True)\",\n \"def total_cost(self, system=None):\\n system = system or self.system()\\n if system == 'grid':\\n cost = self['system (grid)']['internal system nodal cost']\\n else:\\n cost = self['system (%s)' % system]['system nodal cost']\\n cost = float(cost)\\n return cost\",\n \"def total_cost(self):\\n if self.goal:\\n return self.goal + (self.community_contribution or 0)\\n else:\\n return 0\",\n \"def compute_cost(AL, Y):\\n pass\",\n \"def calc_cost(self):\\n cost = 0\\n for i,[source, sinks] in enumerate(self.nets):\\n self.costs[i] = self.calc_half_perimeter(source, sinks)\\n cost += self.costs[i]\\n self.cost = cost\\n return True\",\n \"def cost(self, n_batteries, houseList, wireCost, batteryCost):\\n\\n\\t\\tcost = 0\\n\\t\\tcost += n_batteries*batteryCost\\n\\t\\tfor house in houseList:\\n\\t\\t\\tcost += self.manhattenDistance(house.position, house.batteryAssignment.position)*wireCost\\n\\t\\treturn cost\",\n \"def total_management_cost(self):\\n total = 0\\n total += self.output_dict['insurance_usd']\\n total += self.output_dict['construction_permitting_usd']\\n total += self.output_dict['bonding_usd']\\n total += self.output_dict['project_management_usd']\\n total += self.output_dict['markup_contingency_usd']\\n total += self.output_dict['engineering_usd']\\n total += self.output_dict['site_facility_usd']\\n return total\",\n \"def get_total_cost(self):\\n total_cost = sum([item.quantity * item.product.price for item in self.orderitem_set.all()])\\n return total_cost - total_cost * (self.discount / Decimal('100'))\",\n \"def compute_cost(AL, Y):\\n pass\",\n \"def print_solution(data, manager, routing, solution):\\n # create a file in order to save the solution steps.\\n sol_fpath = gbo.create_results_name()\\n print(f'Objective: {solution.ObjectiveValue()}')\\n max_route_distance = 0\\n for vehicle_id in range(data['num_vehicles']):\\n index = routing.Start(vehicle_id)\\n plan_output = 'Route for vehicle {}:\\\\n'.format(vehicle_id)\\n route_distance = 0\\n while not routing.IsEnd(index):\\n plan_output += ' {} -> '.format(manager.IndexToNode(index))\\n previous_index = index\\n index = solution.Value(routing.NextVar(index))\\n route_distance += routing.GetArcCostForVehicle(\\n previous_index, index, vehicle_id)\\n plan_output += '{}\\\\n'.format(manager.IndexToNode(index))\\n plan_output += 'Distance of the route: {}m\\\\n'.format(route_distance)\\n print(plan_output)\\n gbo.write_solution_to_file(sol_fpath, plan_output)\\n max_route_distance = max(route_distance, max_route_distance)\\n print('Maximum of the route distances: {}m'.format(max_route_distance))\\n gbo.write_solution_to_file(sol_fpath, \\\"route distance: \\\"+str(max_route_distance))\",\n \"def final_cost(self):\\n return self.algorithm_results[-1].final_cost\",\n \"def print_solution(data, manager, routing, solution):\\r\\n time_dimension = routing.GetDimensionOrDie('Time')\\r\\n total_distance = 0\\r\\n total_load = 0\\r\\n total_time = 0\\r\\n for vehicle_id in range(data['num_vehicles']):\\r\\n index = routing.Start(vehicle_id)\\r\\n plan_output = 'Route for vehicle {}:\\\\n'.format(vehicle_id)\\r\\n route_distance = 0\\r\\n route_load = 0\\r\\n while not routing.IsEnd(index):\\r\\n node_index = manager.IndexToNode(index)\\r\\n route_load = route_load + data['demands'][node_index]\\r\\n time_var = time_dimension.CumulVar(index)\\r\\n plan_output += ' {0} Load({1}) Time({2},{3}) -> '.format(node_index, route_load,\\r\\n solution.Min(time_var), solution.Max(time_var))\\r\\n previous_index = index\\r\\n index = solution.Value(routing.NextVar(index))\\r\\n route_distance += routing.GetArcCostForVehicle(previous_index, index, vehicle_id)\\r\\n time_var = time_dimension.CumulVar(index)\\r\\n plan_output += ' {0} Load({1}) Time({2},{3})\\\\n'.format(manager.IndexToNode(index), route_load,\\r\\n solution.Min(time_var), solution.Max(time_var))\\r\\n plan_output += 'Distance of the route: {}m\\\\n'.format(route_distance)\\r\\n plan_output += 'Load of the route: {}\\\\n'.format(route_load)\\r\\n plan_output += 'Time of the route: {}min\\\\n'.format(solution.Min(time_var))\\r\\n print(plan_output)\\r\\n total_distance += route_distance\\r\\n total_load += route_load\\r\\n total_time += solution.Min(time_var)\\r\\n print('Total distance of all routes: {}m'.format(total_distance))\\r\\n print('Total load of all routes: {}'.format(total_load))\\r\\n print('Total time of all routes: {}min'.format(total_time))\",\n \"def calculate_costs(self):\\n cost_matrix = self.make_cost_matrix()\\n \\n if self.greedy:\\n # Riesen et al., \\\"Greedy Graph Edit Distance\\\"\\n costs = []\\n psi = []\\n \\n for row in range(self.N):\\n phi = self.M\\n row_min = sys.maxint\\n for column in range(self.N+self.M):\\n if column not in psi:\\n if cost_matrix[row, column] < row_min:\\n row_min = cost_matrix[row, column]\\n phi = column\\n \\n costs.append(row_min)\\n if phi < self.M:\\n psi.append(phi)\\n \\n for row in range(self.N, self.N+self.M):\\n if (row - self.N) not in psi:\\n costs.append(cost_matrix[row, row - self.N])\\n else:\\n # Riesen & Bunke, \\\"Approximate graph edit distance computation by means of bipartite graph matching\\\"\\n row_ind, col_ind = optimize.linear_sum_assignment(cost_matrix)\\n \\n if self.verbose:\\n for row, column in (row_ind, col_ind):\\n value = cost_matrix[row, column]\\n print '%d, %d, %.4f' % (row, column, value)\\n \\n return row_ind, col_ind, cost_matrix[row_ind, col_ind]\",\n \"def print_solution(data, manager, routing, assignment):\\r\\n total_distance = 0\\r\\n total_load = 0\\r\\n for vehicle_id in range(data['num_vehicles']):\\r\\n index = routing.Start(vehicle_id)\\r\\n plan_output = 'Route for vehicle {}:\\\\n'.format(vehicle_id+1)\\r\\n route_distance = 0\\r\\n route_load = 0\\r\\n while not routing.IsEnd(index):\\r\\n node_index = manager.IndexToNode(index)\\r\\n route_load += data['demands'][node_index]\\r\\n plan_output += ' {0} Load({1}) -> '.format(node_index, route_load)\\r\\n previous_index = index\\r\\n index = assignment.Value(routing.NextVar(index))\\r\\n route_distance += routing.GetArcCostForVehicle(\\r\\n previous_index, index, vehicle_id)\\r\\n plan_output += ' {0} Load({1})\\\\n'.format(manager.IndexToNode(index),\\r\\n route_load)\\r\\n plan_output += 'Distance of the route: {}m\\\\n'.format(route_distance)\\r\\n plan_output += 'Load of the route: {}\\\\n'.format(route_load)\\r\\n print(plan_output)\\r\\n total_distance += route_distance\\r\\n total_load += route_load\\r\\n print('Total distance of all routes: {}m'.format(total_distance))\\r\\n print('Total load of all routes: {}'.format(total_load))\",\n \"def total_cost(self, X, Y, thetas = None):\\n \\n if thetas == None:\\n thetas = self.thetas\\n \\n J = 0.0\\n m = X.shape[0]\\n for x, true_indx in zip(X, Y):\\n y = np.zeros(self.noutputs)\\n y[true_indx] = 1.\\n h_theta = self._forward_prop(x, thetas)[-1]\\n J += self.cost(h_theta, y)\\n \\n return np.sum(J)/m\",\n \"def calculate_cost_for_certificate_batch(self):\\n num_inputs = 1\\n # output per recipient\\n num_outputs = len(self.certificates_to_issue)\\n # plus revocation outputs\\n num_outputs += sum(1 for c in self.certificates_to_issue.values() if c.revocation_key)\\n # plus global revocation, change output, and OP_RETURN\\n num_outputs += 3\\n self.total = tx_utils.calculate_tx_total(self.tx_cost_constants, num_inputs, num_outputs)\\n return self.total\",\n \"def heuristic_cal(current: list, goal: list) -> int:\\n\\n current_locations = state_to_locations(current)\\n goal_locations = state_to_locations(goal)\\n\\n h_val = 0 # Tracks the cost of the heuristic function\\n for i in range(1, 16):\\n h_val += (abs(current_locations[i][0] - goal_locations[i][0]) +\\n abs(current_locations[i][1] - goal_locations[i][1]))\\n \\\"\\\"\\\" Loops through both lists of locations and adds the Manhattan distance \\n of each number to the sum h_val. The range is from 1 to 16 because the \\n blank in either state is not taken into account.\\\"\\\"\\\"\\n\\n return h_val\",\n \"def out_calc_e_total(target, fp_lst):\\r\\n e_total_list = []\\r\\n\\r\\n for in_node in range(n_hidden): # For each hidden layer node\\r\\n for out_node in range(n_output): # Find ETotal for weight connected to each output node\\r\\n e_total = -1 * (target[out_node] - fp_lst[1][out_node]) * fp_lst[1][out_node] * (\\r\\n 1 - fp_lst[1][out_node]) * fp_lst[0][in_node]\\r\\n\\r\\n e_total_list.append(e_total)\\r\\n\\r\\n return e_total_list\",\n \"def sim_average_cost(self, dictionary):\\n\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\tprint \\\"Running: sim_average_cost\\\"\\n\\t\\tf = open(toggles.OUTPUT_PATH + toggles.RUN_NAME + '_estimated_costs.csv', 'a')\\n\\n\\t\\tfor p in toggles.CHOSEN_PREDS:\\n\\t\\t\\tpred_cost = 0.0\\n\\t\\t\\tpred = Predicate.objects.all().get(pk=p+1)\\n\\t\\t\\tf.write(pred.question.question_text + '\\\\n')\\n\\n\\t\\t\\t#iterate through to find each ip cost\\n\\t\\t\\tfor ip in IP_Pair.objects.filter(predicate=pred):\\n\\t\\t\\t\\titem_cost = 0.0\\n\\t\\t\\t\\t# sample toggles.COST_SAMPLES times\\n\\t\\t\\t\\tfor x in range(toggles.COST_SAMPLES):\\n\\t\\t\\t\\t\\t# running one sampling\\n\\t\\t\\t\\t\\twhile ip.status_votes < toggles.NUM_CERTAIN_VOTES:\\n\\t\\t\\t\\t\\t\\t# get the vote\\n\\t\\t\\t\\t\\t\\tvalue = choice(dictionary[ip])\\n\\t\\t\\t\\t\\t\\tif value == True:\\n\\t\\t\\t\\t\\t\\t\\tip.value += 1\\n\\t\\t\\t\\t\\t\\t\\tip.num_yes += 1\\n\\t\\t\\t\\t\\t\\telif value == False:\\n\\t\\t\\t\\t\\t\\t\\tip.value -= 1\\n\\t\\t\\t\\t\\t\\t\\tip.num_no +=1\\n\\n\\t\\t\\t\\t\\t\\tip.status_votes += 1\\n\\n\\t\\t\\t\\t\\t\\t# check if ip is done\\n\\t\\t\\t\\t\\t\\tif ip.status_votes == toggles.NUM_CERTAIN_VOTES:\\n\\t\\t\\t\\t\\t\\t\\t\\tif ip.value > 0:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tuncertaintyLevel = btdtr(ip.num_yes+1, ip.num_no+1, toggles.DECISION_THRESHOLD)\\n\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tuncertaintyLevel = btdtr(ip.num_no+1, ip.num_yes+1, toggles.DECISION_THRESHOLD)\\n\\t\\t\\t\\t\\t\\t\\t\\tif uncertaintyLevel < toggles.UNCERTAINTY_THRESHOLD:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\titem_cost += (ip.num_yes + ip.num_no)\\n\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tip.status_votes -= 2\\n\\n\\t\\t\\t\\t\\t# reset values\\n\\t\\t\\t\\t\\tip.value = 0\\n\\t\\t\\t\\t\\tip.num_yes = 0\\n\\t\\t\\t\\t\\tip.num_no = 0\\n\\t\\t\\t\\t\\tip.status_votes = 0\\n\\n\\t\\t\\t\\titem_cost = item_cost/float(toggles.COST_SAMPLES)\\n\\t\\t\\t\\tpred_cost += item_cost\\n\\t\\t\\t\\tf.write(ip.item.name + ': ' + str(item_cost) + \\\" \\\")\\n\\n\\t\\t\\tpred_cost = float(pred_cost)/IP_Pair.objects.filter(predicate=pred).count()\\n\\t\\t\\tf.write('\\\\npredicate average cost: ' + str(pred_cost) + '\\\\n \\\\n')\\n\\t\\tf.close()\\n\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\tprint \\\"Wrote File: \\\" + toggles.OUTPUT_PATH + toggles.RUN_NAME + '_estimated_costs.csv'\",\n \"def quadratic_cost(output_out, target_out):\\r\\n total = 0\\r\\n for target_node in range(len(target_out)): # For each target data set\\r\\n for output_node in range(len(output_out)): # For each output node\\r\\n total += (0.5 * (target_out[target_node][output_node] - output_out[output_node])) ** 2\\r\\n\\r\\n total = 1 / total\\r\\n return total\",\n \"def get_cost(self) -> float:\\n return math.e / self.fitness\",\n \"def compute_fitness(solution):\\n\\n solution_fitness = 0.0\\n\\n for index in range(len(solution)):\\n waypoint1 = solution[index - 1]\\n waypoint2 = solution[index]\\n solution_fitness += waypoint_distances[frozenset([waypoint1, waypoint2])]\\n\\n return solution_fitness\",\n \"def cost(foods, foods_used):\\n cost = 0.00\\n for i, count in foods_used.items():\\n cost += (foods[i]['serving_cost'] * count)\\n return cost\",\n \"def update_current_sol_and_cost(self,sol=None):\\n\\n # Update current sol if argument given\\n if sol is not None:\\n self.current_sol = sol\\n \\n # Update residual and cost\\n try:\\n self.residual = self.sketch_reweighted - self.sketch_of_solution(self.current_sol)\\n self.current_sol_cost = np.linalg.norm(self.residual)\\n except AttributeError: # We are here if self.current_sol does not exist yet\\n self.current_sol, self.residual = None, self.sketch_reweighted\\n self.current_sol_cost = np.inf\",\n \"def update_totals(self):\\n # Reset counts to 0\\n self.total_f = self.total_s = self.total_intra = self.total_mac_regular = self.total_mac_infected = \\\\\\n self.total_mac_activated = self.total_regular_fast = self.total_regular_slow = self.total_infected_fast = \\\\\\n self.total_infected_slow = self.total_activated_fast = self.total_activated_slow = self.total_f_degree = \\\\\\n self.total_s_degree = self.total_activation = 0\\n self.total_f_o2 = self.total_s_o2 = 0.0\\n\\n for node in self.node_list.values():\\n # Get values from node\\n fast_in_node = node.subpopulations[BACTERIA_FAST]\\n slow_in_node = node.subpopulations[BACTERIA_SLOW]\\n intra_in_node = node.subpopulations[BACTERIA_INTRACELLULAR]\\n reg_mac_in_node = node.subpopulations[MACROPHAGE_REGULAR]\\n inf_mac_in_node = node.subpopulations[MACROPHAGE_INFECTED]\\n act_mac_in_node = node.subpopulations[MACROPHAGE_ACTIVATED]\\n degree = node.degree\\n o2_tens = node.oxygen_tension\\n # Update relevant totals\\n self.total_f += fast_in_node\\n self.total_s += slow_in_node\\n self.total_intra += intra_in_node\\n self.total_mac_regular += reg_mac_in_node\\n self.total_mac_infected += inf_mac_in_node\\n self.total_mac_activated += act_mac_in_node\\n self.total_regular_fast += fast_in_node * reg_mac_in_node\\n self.total_regular_slow += slow_in_node * reg_mac_in_node\\n self.total_infected_fast += fast_in_node * inf_mac_in_node\\n self.total_infected_slow += slow_in_node * inf_mac_in_node\\n self.total_activated_fast += fast_in_node * act_mac_in_node\\n self.total_activated_slow += slow_in_node * act_mac_in_node\\n # TODO - check usage of degree\\n self.total_f_degree += fast_in_node * degree\\n self.total_s_degree += slow_in_node * degree\\n self.total_f_o2 += fast_in_node * (1/o2_tens)\\n self.total_s_o2 += slow_in_node * o2_tens\\n self.total_activation += reg_mac_in_node * inf_mac_in_node\",\n \"def dv_update(self, dv_list):\\n for line in dv_list:\\n line_sep = line.split(',')\\n other_name = line_sep[0] + ':' + line_sep[1]\\n other_cost = float(line_sep[2])\\n self.distance_vector[other_name] = other_cost\",\n \"def get_cost(self):\\n if self.distance == 0:\\n for i in range(1, len(self.cities) + 1):\\n point1 = self.cities[i - 1]\\n point2 = self.cities[i % len(self.cities)]\\n self.distance += self.distance_to(point1, point2)\\n return self.distance\",\n \"def compute_tour_cost(self, list_cities: list) -> float:\\n cost = 0.0\\n n = self.tour_size # Number of cities\\n for i in range(n):\\n if i + 1 < n:\\n cost += list_cities[self.tour_ids[i]].distance(list_cities[self.tour_ids[i + 1]])\\n else:\\n cost += list_cities[self.tour_ids[i]].distance(list_cities[self.tour_ids[0]])\\n\\n return cost\",\n \"def cost(solution):\\n cost = 0\\n alm_count = 0 # alignment operand/operator count\\n fst_len = len(solution[0])\\n snd_len = len(solution[1])\\n min_len = min(fst_len, snd_len)\\n\\n for i in range(min_len):\\n if solution[0][i] == solution[1][i]:\\n alm_count += 1\\n\\n max_spaces = max(solution[0].count(\\\" \\\"), solution[1].count(\\\" \\\"))\\n cost = ((alm_count * 2.0) + max_spaces) / 3.0\\n\\n return cost\",\n \"def cost(self):\\n node, path_back = self, []\\n cost = 0\\n while node:\\n path_back.append(node)\\n if node.action is not None:\\n cost = cost + node.action.cost\\n node = node.parent\\n # remove one due to root empty node \\n #cost = cost-1\\n return [cost, list(reversed(path_back))]\",\n \"def cost(self):\\n abs_cost = sum(f['price'] * f['qty'] for f in self.fills)\\n return -abs_cost if self.is_ask() else abs_cost\",\n \"def cost(cost: List[float]) -> List[float]:\\n\\n data = pd.DataFrame({'cost':np.array(cost).clip(min=0)})\\n data['cost'] = data['cost'].rolling(window=data.shape[0],min_periods=1).sum()\\n \\n return data['cost'].tolist()\",\n \"def total_cost(path: Path) -> float:\\n\\t\\n\\tdistance = calc_total_dist(path)\\n\\tavg_speed = calc_average_speed(path)\\n\\t\\n\\t# Speed is less important, but gets a huge multiplier, because speed and\\n\\t# \\tdistance are in different units. Speed requires a high ratio to have\\n\\t# \\tsimilar amounts of variation.\\n\\tSPEED_DISTANCE_COST_RATIO = 7865.099\\n\\t\\n\\treturn (\\n\\t\\t(distance * 1) +\\n\\t\\t(-avg_speed * SPEED_DISTANCE_COST_RATIO)\\n\\t)\",\n \"def calculate_expected_cost(melon_cost, melon_count):\\n\\n return melon_cost + melon_count\",\n \"def cost_function(self, config_samples):\\n cost = self.work_tracker(config_samples)\\n return cost\",\n \"def __cost_to_goal(self, goal_state):\\n cost = 0\\n for i in range(len(goal_state) * len(goal_state[0])):\\n if(i != 0):\\n pos_goal = self.__get_position(i, goal_state)\\n pos_current = self.__get_position(i, self.puzzle)\\n cost += self.__manhattan(pos_current[0], pos_current[1], pos_goal[0], pos_goal[1])\\n return cost\",\n \"def dp_all(foods, cal_goal, pro_goal, carb_goal, fat_goal):\\n costs = init_four_d_array((cal_goal, pro_goal, carb_goal, fat_goal),\\n 999999999)\\n foods_used = init_four_d_array((cal_goal, pro_goal, carb_goal, fat_goal),\\n {})\\n\\n for i in range(cal_goal):\\n for j in range(pro_goal):\\n for k in range(carb_goal):\\n for l in range(fat_goal):\\n for n in range(len(foods)):\\n food = foods[n]\\n if (int(food['calories']) > i\\n or int(food['protein']) > j\\n or int(food['carbs']) > k\\n or int(food['fat']) > l):\\n continue\\n if (costs[i - int(food['calories'])]\\n [j - int(food['protein'])]\\n [k - int(food['carbs'])]\\n [l - int(food['fat'])]\\n == 999999999):\\n prev_cost = 0\\n prev_foods_used = {}\\n else:\\n prev_cost = (macros[i - int(food['calories'])]\\n [j - int(food['protein'])]\\n [j - int(food['carbs'])]\\n [j - int(food['fat'])])\\n prev_foods_used = \\\\\\n (foods_used[i - int(food['calories'])]\\n [j - int(food['protein'])]\\n [k - int(food['carbs'])]\\n [l - int(food['fat'])]).copy()\\n new_cal = calories(\\n foods, prev_foods_used) + food['calories']\\n new_pro = protein(\\n foods, prev_foods_used) + food['protein']\\n new_car = carbs(\\n foods, prev_foods_used) + food['protein']\\n new_fat = fat(\\n foods, prev_foods_used) + food['protein']\\n if (costs[i][j] > prev_cost + food['serving_cost']\\n and new_cal > i - 20 and new_cal < i + 10\\n and new_pro < j + 5 and new_pro < j + 5\\n and new_car < j + 5 and new_car < j + 5\\n and new_fat < j + 5 and new_fat < j + 5):\\n costs[i][j][k][l] = prev_cost + \\\\\\n food['serving_cost']\\n try:\\n prev_foods_used[n] += 1\\n except KeyError:\\n prev_foods_used[n] = 1\\n foods_used[i][j][k][l] = prev_foods_used\\n return foods_used[cal_goal - 1][pro_goal - 1][carb_goal - 1][fat_goal - 1]\",\n \"def cost(self):\\n\\t\\treturn self.g + self.h\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n n = Directions.NORTH\\n e = Directions.EAST\\n\\n result = []\\n qu = util.PriorityQueue()\\n visited = set([])\\n current = (problem.getStartState(), \\\"\\\", 0)\\n qu.update(current, 0)\\n costs = {}\\n parents = {}\\n parents[problem.getStartState()] = (problem.getStartState(), \\\"\\\")\\n\\n while not qu.isEmpty():\\n cost, current= qu.pop()\\n visited.add(current[0])\\n\\n if problem.isGoalState(current[0]):\\n result = current[0]\\n break\\n\\n for each in problem.getSuccessors(current[0]):\\n if each[0] not in visited:\\n qu.update(each, cost+each[2])\\n if each[0] not in costs:\\n costs[each[0]] = cost+each[2]\\n parents[each[0]] = (current[0], each[1])\\n elif costs[each[0]] > cost+each[2]:\\n costs[each[0]] = cost + each[2]\\n parents[each[0]] = (current[0], each[1])\\n\\n path = []\\n while parents[result][0] != result:\\n path.append(parents[result][1])\\n result = parents[result][0]\\n\\n path.reverse()\\n result = []\\n for each in path:\\n if each == \\\"South\\\":\\n result.append(s)\\n elif each == \\\"West\\\":\\n result.append(w)\\n elif each == \\\"North\\\":\\n result.append(n)\\n elif each == \\\"East\\\":\\n result.append(e)\\n\\n return result\\n util.raiseNotDefined()\",\n \"def get_cost_updates(self):\\n\\n y = self.get_hidden_values()\\n z = self.get_reconstructed_input(y)\\n\\n L = T.sum((self.x-z)**2, axis=1)\\n\\n cost = T.mean(L)\\n\\n return cost\",\n \"def cost(self, output, labels, weights):\\n raise NotImplementedError('Must be overridden by concrete subclass')\",\n \"def get_hcost(self):\\n hvcost = self.get_hvcost()\\n dcost = self.get_dcost()\\n hcost = hvcost + dcost\\n return hcost\",\n \"def execution_cost(self):\\n #TODO: Compute execution cost\\n total_cost = 0\\n for res_cfg in self.resource_configurations:\\n mapped_tasks = list(filter(lambda x: x.resource_schedule.config == res_cfg, self.schedule_mapping_list))\\n makespan_res = SchedulePlan._makespan(mapped_tasks)\\n total_cost += makespan_res * res_cfg.cost_hour_usd\\n return total_cost\",\n \"def get_sol(self):\",\n \"def cost_function(self, element):\\n return self.maze.cost(element)\",\n \"def total_cost(self, J_content, J_style, alpha=10, beta=40):\\n\\n J_total_cost = alpha * J_content + beta * J_style\\n\\n return J_total_cost\",\n \"def cost(self):\\n return self._cost\",\n \"def cost(self):\\n return self._cost\",\n \"def route_cost(self, route):\\n total_weight = 0\\n c = 0\\n start = route[0]\\n for end in route[1:]:\\n y = float(self.stars[start][end]['weight']) - c\\n t = total_weight + y\\n c = (t - total_weight) - y\\n\\n total_weight = t\\n\\n start = end\\n return total_weight\",\n \"def run_solution1_simple(self):\\n fuel_sum = 0\\n for n in self.data:\\n fuel_sum += self.calculate_fuel(n)\\n return fuel_sum\",\n \"def write_solutions_to_files(\\n solutions: List[Solution], path: Path, folder_name: str = \\\"CodeWars\\\"\\n) -> None:\\n stat = {}\\n path = path / folder_name\\n for solution in solutions:\\n if solution.kyu in stat:\\n stat[solution.kyu] += 1\\n else:\\n stat[solution.kyu] = 1\\n\\n path_to_solution = get_dir(solution, path)\\n path_to_solution.mkdir(parents=True, exist_ok=True)\\n\\n create_file(\\n path_to_solution / f\\\"main{EXTENSIONS[solution.language]}\\\", solution.solution\\n )\\n\\n create_file(path_to_solution / \\\"README.md\\\", f\\\"Link: {solution.link}\\\")\\n\\n kuy_stat = \\\"\\\\n\\\".join([f\\\":star: {x}: {stat[x]} :star:\\\" for x in sorted(stat)])\\n create_file(\\n path / \\\"README.md\\\",\\n f\\\"Total: {sum([stat[x] for x in stat])}\\\\n\\\" f\\\"Detail statistic:\\\\n{kuy_stat}\\\",\\n )\",\n \"def tablecost(self):\\n subtotal_getter = operator.attrgetter(\\\"subtotal\\\")\\n\\n cost = 0.0\\n\\n cost += sum(map(subtotal_getter, self.materials))\\n cost += sum(map(subtotal_getter, self.processes))\\n cost += sum(map(subtotal_getter, self.fasteners))\\n cost += sum(map(subtotal_getter, self.toolings))\\n\\n return cost\",\n \"def print_solution(manager, routing, solution):\\n print('Objective: {} miles'.format(solution.ObjectiveValue()))\\n index = routing.Start(0)\\n plan_output = 'Route for vehicle 0:\\\\n'\\n route_distance = 0\\n while not routing.IsEnd(index):\\n plan_output += ' {} ->'.format(manager.IndexToNode(index))\\n previous_index = index\\n index = solution.Value(routing.NextVar(index))\\n route_distance += routing.GetArcCostForVehicle(previous_index, index, 0)\\n plan_output += ' {}\\\\n'.format(manager.IndexToNode(index))\\n print(plan_output)\\n plan_output += 'Route distance: {}miles\\\\n'.format(route_distance)\",\n \"def print_solution(manager, routing, solution):\\n print('Objective: {} miles'.format(solution.ObjectiveValue()))\\n index = routing.Start(0)\\n plan_output = 'Route for vehicle 0:\\\\n'\\n route_distance = 0\\n while not routing.IsEnd(index):\\n plan_output += ' {} ->'.format(manager.IndexToNode(index))\\n previous_index = index\\n index = solution.Value(routing.NextVar(index))\\n route_distance += routing.GetArcCostForVehicle(previous_index, index, 0)\\n plan_output += ' {}\\\\n'.format(manager.IndexToNode(index))\\n print(plan_output)\\n plan_output += 'Route distance: {}miles\\\\n'.format(route_distance)\",\n \"def twoCitySchedCost(self, costs: List[List[int]]) -> int:\\n def abs_diff_compare(x=[1,2], y=[3,4]):\\n x1=x[0]-x[1] if x[0]>=x[1] else x[1]-x[0]\\n y1=y[0]-y[1] if y[0]>=y[1] else y[1]-x[0]\\n return x1 if x1>y1 else y1\\n save_costs=costs\\n costs.sort(reverse=True, key=abs_diff_compare)\\n print(costs)\\n nA=0\\n nB=0\\n tc=0\\n num_people=len(costs)\\n max_ppl=num_people//2\\n \\n for x in costs:\\n if nA< max_ppl and nB< max_ppl :\\n if x[0] <x[1]:\\n nA+=1\\n tc+=x[0]\\n else:\\n nB+=1\\n tc+=x[1]\\n elif nA< max_ppl:\\n nA+=1\\n tc+=x[0]\\n elif nB< max_ppl:\\n nB+=1\\n tc+=x[1]\\n \\n \\n return tc\",\n \"def evaluate(G, path, home_idxs, verbose=False):\\n dropoffs = assign_dropoffs(G, path, home_idxs)\\n cost, msg = cost_of_solution(G, path, dropoffs, shortest=all_pairs_dists)\\n if verbose:\\n print(msg)\\n\\n return cost\",\n \"def totalValue(self):\\n\\n\\t\\tvalue = 0\\n\\t\\tfor bottle in self.bottles:\\n\\t\\t\\tvalue += bottle.inflatedCost\\n\\n\\t\\treturn value\",\n \"def rate(way):\\n cost = 0\\n for i in range(len(way)-1):\\n cost += DISTANCES[way[i]][way[i+1]]\\n return cost\",\n \"def calculate_cost(self, **kwargs):\\n costs = {}\\n if np.abs(self.agent.get_position()[0]) > self.x_lim:\\n costs['cost_outside_bounds'] = 1.\\n # sum all costs in one total cost\\n costs['cost'] = min(1, sum(v for k, v in costs.items() if k.startswith('cost_')))\\n\\n return costs\",\n \"def computeAssignments(solution, h, data, sumW, checkers, hini=None):\\n minHours = data[\\\"minHours\\\"]\\n hours = data[\\\"hours\\\"]\\n z = solution[\\\"z\\\"]\\n w = solution[\\\"w\\\"]\\n\\n mustWork = []\\n canWork = []\\n\\n # sort nurses, first by those who work\\n sorted_nurses = sorted(range(data[\\\"nNurses\\\"]), key=lambda n: solution[\\\"z\\\"][n], reverse=True)\\n # print(solution[\\\"z\\\"])\\n # print(sorted_nurses)\\n # print(\\\"\\\")\\n\\n # for each nurse\\n for n in sorted_nurses:\\n\\n # canWork Check-------------------------------\\n canWork_check = checkIfCanWork_fast(solution, h, n, data, sumW, checkers=checkers, hini=hini)\\n if canWork_check:\\n\\n\\n mustWork_check = checkIfMustWork_fast(solution, h, n, data, sumW, True, checkers, hini)\\n if mustWork_check:\\n mustWork.append(n)\\n else: \\n canWork.append(n)\\n\\n # # mustWork Check-------------------------------\\n # # avoid repeating canWork_check\\n # mustWork_check = checkIfMustWork_fast(solution, h, n, data, sumW, canWork_check, checkers, hini)\\n # if mustWork_check:\\n # mustWork.append(n)\\n # else:\\n \\n return mustWork, canWork\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60075754","0.599813","0.5897581","0.58958864","0.58943343","0.58902836","0.5857024","0.5817814","0.5779555","0.5712807","0.57073516","0.57030547","0.57030547","0.56806123","0.5668559","0.56510866","0.5595581","0.55908483","0.5583591","0.5566087","0.5564772","0.55473834","0.5538532","0.55384016","0.5531394","0.54906267","0.54810053","0.5449483","0.5437818","0.54318035","0.54138047","0.5407744","0.5402094","0.5396354","0.53957003","0.53825486","0.5367685","0.5359805","0.5347463","0.53414387","0.5337783","0.53338987","0.5328524","0.531086","0.5305476","0.52957755","0.5277446","0.52651495","0.5253236","0.5250137","0.5241694","0.5241017","0.52401155","0.52335703","0.5222778","0.5207698","0.5204839","0.51982987","0.5196249","0.5185673","0.51658297","0.5165449","0.5163124","0.51546896","0.513614","0.5134867","0.51340955","0.5129634","0.5129456","0.5127308","0.51260704","0.5125262","0.51196253","0.5110015","0.50965434","0.509544","0.50931644","0.5087192","0.50844395","0.507956","0.5071594","0.5067425","0.50657815","0.5060947","0.5060405","0.50475866","0.5042666","0.50414884","0.50414884","0.5041154","0.5038599","0.50359815","0.50134265","0.50134075","0.5012803","0.5004829","0.49951726","0.49928454","0.49927717","0.49858403","0.49833637"],"string":"[\n \"0.60075754\",\n \"0.599813\",\n \"0.5897581\",\n \"0.58958864\",\n \"0.58943343\",\n \"0.58902836\",\n \"0.5857024\",\n \"0.5817814\",\n \"0.5779555\",\n \"0.5712807\",\n \"0.57073516\",\n \"0.57030547\",\n \"0.57030547\",\n \"0.56806123\",\n \"0.5668559\",\n \"0.56510866\",\n \"0.5595581\",\n \"0.55908483\",\n \"0.5583591\",\n \"0.5566087\",\n \"0.5564772\",\n \"0.55473834\",\n \"0.5538532\",\n \"0.55384016\",\n \"0.5531394\",\n \"0.54906267\",\n \"0.54810053\",\n \"0.5449483\",\n \"0.5437818\",\n \"0.54318035\",\n \"0.54138047\",\n \"0.5407744\",\n \"0.5402094\",\n \"0.5396354\",\n \"0.53957003\",\n \"0.53825486\",\n \"0.5367685\",\n \"0.5359805\",\n \"0.5347463\",\n \"0.53414387\",\n \"0.5337783\",\n \"0.53338987\",\n \"0.5328524\",\n \"0.531086\",\n \"0.5305476\",\n \"0.52957755\",\n \"0.5277446\",\n \"0.52651495\",\n \"0.5253236\",\n \"0.5250137\",\n \"0.5241694\",\n \"0.5241017\",\n \"0.52401155\",\n \"0.52335703\",\n \"0.5222778\",\n \"0.5207698\",\n \"0.5204839\",\n \"0.51982987\",\n \"0.5196249\",\n \"0.5185673\",\n \"0.51658297\",\n \"0.5165449\",\n \"0.5163124\",\n \"0.51546896\",\n \"0.513614\",\n \"0.5134867\",\n \"0.51340955\",\n \"0.5129634\",\n \"0.5129456\",\n \"0.5127308\",\n \"0.51260704\",\n \"0.5125262\",\n \"0.51196253\",\n \"0.5110015\",\n \"0.50965434\",\n \"0.509544\",\n \"0.50931644\",\n \"0.5087192\",\n \"0.50844395\",\n \"0.507956\",\n \"0.5071594\",\n \"0.5067425\",\n \"0.50657815\",\n \"0.5060947\",\n \"0.5060405\",\n \"0.50475866\",\n \"0.5042666\",\n \"0.50414884\",\n \"0.50414884\",\n \"0.5041154\",\n \"0.5038599\",\n \"0.50359815\",\n \"0.50134265\",\n \"0.50134075\",\n \"0.5012803\",\n \"0.5004829\",\n \"0.49951726\",\n \"0.49928454\",\n \"0.49927717\",\n \"0.49858403\",\n \"0.49833637\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":245,"numItemsPerPage":100,"numTotalItems":95772,"offset":24500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sInJlcG9JZHMiOlsiNjc1Mzc2ODJkMmE2Mjg0NzVhMWJmZmNkIl0sImlhdCI6MTc5MTA0NzcxNiwianRpIjoiYTA2ODc5MjctOTgyYy00ZjA3LTk0NzEtNWIwMGRiODM4ZjBlIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3OTEwNTEzMTYsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.jSzly-u66usF-lhnz6oBI3geb0twPTw0uRgK_s_HM8PuMSsUi3rrcVJAjd1cR899cVrM8d0iDWcO7KYxPOgIDA","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 |
|---|---|---|---|---|---|---|
Agent has been selected and a grain of sand is added to it. If the cell exceeds it capacity it add's itself to the model's spill queue. The model handles distributing the spill to adjacent cells. | def step(self):
self.grains += 1
if self.grains > self.spill_size:
print('spill -> ', self.agent_id)
self.model.spill(self) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def spill(self, agent):\n self.spill_list.append(agent)",
"def step(self):\n self.age += 1\n self.move_agent()\n self.sugar -= self.metabolism\n\n # Eat sugar\n available_sugar = self.get_sugar(self.pos).amount\n self.sugar += available_sugar\n# self.total_... | [
"0.70932084",
"0.61752456",
"0.6172666",
"0.57589626",
"0.55338156",
"0.54990155",
"0.5498288",
"0.5404687",
"0.5382121",
"0.5283981",
"0.5247643",
"0.5209323",
"0.51918066",
"0.5176298",
"0.5169959",
"0.5154262",
"0.51332146",
"0.5123966",
"0.5116275",
"0.508177",
"0.5068731... | 0.70183915 | 1 |
Set the state of the agent to the next state | def advance(self):
self._state = self._next_state | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_next_state(self, state):\n self.next_state = state",
"def next_state(self, action):\n self.state = self.states[action][self.state]",
"def go_to_next_state(self):\n pass",
"def next(self):\n self.state += 1\n if self.state > 1:\n self.state = 0",
"def ne... | [
"0.77334386",
"0.7549452",
"0.7462713",
"0.7221868",
"0.7030984",
"0.6958567",
"0.6888716",
"0.6752713",
"0.67414314",
"0.6740218",
"0.67339367",
"0.6675615",
"0.6600173",
"0.65947825",
"0.65842956",
"0.658048",
"0.6566541",
"0.6556136",
"0.65397716",
"0.6539616",
"0.6531275"... | 0.71685076 | 4 |
Add agent to model's spill queue. | def spill(self, agent):
self.spill_list.append(agent) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_to_grid_queue(self, agent):\n self.pipes[agent.grid_queue].send(\"add\")\n self.pipes[agent.grid_queue].send(agent)",
"def add_to_simulation(self,agent):\n self.agents[agent.name] = agent\n self.network.add_node(agent)\n \n #agent given a grid queue at initializa... | [
"0.7249907",
"0.724359",
"0.6364773",
"0.6199888",
"0.610778",
"0.59546876",
"0.59015363",
"0.58994764",
"0.5738974",
"0.5690717",
"0.5538615",
"0.5536676",
"0.5536676",
"0.5536676",
"0.5536676",
"0.5536676",
"0.5536676",
"0.5536676",
"0.5536676",
"0.5536676",
"0.5536676",
... | 0.82388806 | 0 |
Process spill_list and advance the model one step. | def step(self):
for c in self.spill_list:
self._schedule.step() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def step(self):\n\n self.grains += 1\n\n if self.grains > self.spill_size:\n print('spill -> ', self.agent_id)\n self.model.spill(self)",
"def spill(self, agent):\n self.spill_list.append(agent)",
"def step(self, memories):\n return",
"def _preprocess(self, o... | [
"0.5933351",
"0.5655595",
"0.5262983",
"0.5020804",
"0.49819398",
"0.49550286",
"0.49170116",
"0.4878095",
"0.48729232",
"0.486313",
"0.48542383",
"0.4846436",
"0.48377305",
"0.48368984",
"0.48039612",
"0.47895807",
"0.47695318",
"0.47682866",
"0.47671297",
"0.47658867",
"0.4... | 0.6663731 | 0 |
/mesa/visualization/modules/CanvasGridVisualization.py is directly accessing Model.grid | def grid(self):
return self._grid | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_grid(self):\r\n return self.grid",
"def grid(self) -> aa.Grid2D:\r\n return self.analysis.dataset.grid",
"def grid(self):\n return self.__grid",
"def grid(self):\n if hasattr(self.cls, \"grid\"):\n return self.cls.grid",
"def getGrid(self):\n\n\t\t\treturn sel... | [
"0.70682144",
"0.6907529",
"0.68824196",
"0.68298477",
"0.6724462",
"0.66187364",
"0.6615151",
"0.658515",
"0.64839584",
"0.6413186",
"0.6411681",
"0.6379451",
"0.62074244",
"0.6158653",
"0.61133534",
"0.6071972",
"0.6042853",
"0.6031144",
"0.6021297",
"0.601962",
"0.5985744"... | 0.68091476 | 4 |
mesa_ABM/examples_ABM/color_patches/mesa/visualization/ModularVisualization.py", line 278, in run_model | def schedule(self):
return self._schedule | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\r\n \r\n world = WorldModel()\r\n #uncomment these lines and comment out the next 2 if you want to use the\r\n #full Baxter model\r\n #print \"Loading full Baxter model (be patient, this will take a minute)...\"\r\n #world.loadElement(os.path.join(model_dir,\"baxter.rob\"))\r\n pri... | [
"0.6065024",
"0.58139783",
"0.57608604",
"0.5726678",
"0.56774104",
"0.56704617",
"0.56335276",
"0.5604466",
"0.5602456",
"0.5543141",
"0.55224913",
"0.55002517",
"0.54867035",
"0.54674447",
"0.54572403",
"0.54383457",
"0.54381377",
"0.5433474",
"0.5411144",
"0.53975135",
"0.... | 0.0 | -1 |
This is the first time that the agent sees the layout of the game board. Here, we choose a path to the goal. In this phase, the agent should compute the path to the goal and store it in a local variable. All of the work is done in this method! | def registerInitialState(self, state):
if self.searchFunction == None: raise Exception("No search function provided for SearchAgent")
starttime = time.time()
problem = self.searchType(state) # Makes a new search problem
self.actions = self.searchFunction(problem) # Find a path
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculateFirstPath(self):\n rd.shuffle(self.goals)\n self.path = self.goals",
"def calculateNewPath(self):\r\n\r\n\t\tnodeDict = self.simulationHandle.getMap().getNodeDict()\r\n\t\tdistDict = self.simulationHandle.getMap().getDistDict()\r\n\r\n\t\tself.pathToGoal = pathfinder.findPath(self.curr... | [
"0.71514714",
"0.69542295",
"0.6888776",
"0.6844573",
"0.6621183",
"0.66102225",
"0.6598708",
"0.65912944",
"0.6584372",
"0.65817904",
"0.64739156",
"0.6460624",
"0.64539826",
"0.63936776",
"0.63668495",
"0.6326644",
"0.6316151",
"0.63078594",
"0.6255218",
"0.6253189",
"0.624... | 0.0 | -1 |
Returns the next action in the path chosen earlier (in registerInitialState). Return Directions.STOP if there is no further action to take. | def getAction(self, state):
if 'actionIndex' not in dir(self): self.actionIndex = 0
i = self.actionIndex
self.actionIndex += 1
if i < len(self.actions):
return self.actions[i]
else:
return Directions.STOP | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def action(self):\n next_action = self.strategy.get_next_move(self)\n return next_action",
"def get_action(self, state):\n if self.globSeq == []:\n self.globSeq = self.graphSearch(state)\n if not(self.globSeq):\n return Directions.STOP\n return sel... | [
"0.72942245",
"0.703718",
"0.703718",
"0.6975734",
"0.687244",
"0.68233156",
"0.6763603",
"0.66571885",
"0.65745246",
"0.6558087",
"0.6465374",
"0.64216137",
"0.63660026",
"0.63593185",
"0.621351",
"0.61860585",
"0.6183947",
"0.6181521",
"0.61599606",
"0.61497635",
"0.6118962... | 0.701559 | 4 |
Stores the start and goal. | def __init__(self, gameState, costFn=lambda x: 1, goal=(1, 1), start=None, warn=True, visualize=True):
self.walls = gameState.getWalls()
self.startState = gameState.getPacmanPosition()
if start != None: self.startState = start
self.goal = goal
self.costFn = costFn
self.vi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_goal(self, goal):\r\n self.goal = goal\r\n self.start_time = self.get_current_time()",
"def replanning_path(self):\n start_state = self.extract_start_state()\n goal_state = self.extract_goal_state()",
"def update_goal(self):\n pass",
"def goal(self, goal):\n\n ... | [
"0.6584438",
"0.5886289",
"0.5828094",
"0.5670449",
"0.5650115",
"0.5611662",
"0.5580858",
"0.5474834",
"0.547023",
"0.5460961",
"0.5458281",
"0.5414585",
"0.5401672",
"0.5395571",
"0.5349603",
"0.5334042",
"0.5330076",
"0.5278849",
"0.5277182",
"0.5264969",
"0.5221725",
"0... | 0.0 | -1 |
Returns successor states, the actions they require, and a cost of 1. | def getSuccessors(self, state):
successors = []
for action in [Directions.NORTH, Directions.SOUTH, Directions.EAST, Directions.WEST]:
x, y = state
dx, dy = Actions.directionToVector(action)
nextx, nexty = int(x + dx), int(y + dy)
if not self.walls[nextx][... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def successorStates(self, state):\r\n\r\n successors = []\r\n\r\n for action in Directions.CARDINAL:\r\n x, y = state\r\n dx, dy = Actions.directionToVector(action)\r\n nextx, nexty = int(x + dx), int(y + dy)\r\n\r\n if (not self.walls[nextx][nexty]):\r\n ... | [
"0.69858253",
"0.67503315",
"0.67503315",
"0.6592919",
"0.65374583",
"0.6465142",
"0.6464361",
"0.6457984",
"0.6457984",
"0.64522135",
"0.64344466",
"0.6423142",
"0.64227897",
"0.6419713",
"0.6419713",
"0.6419713",
"0.64137363",
"0.6407583",
"0.6382118",
"0.6361048",
"0.63566... | 0.62914854 | 29 |
Returns the cost of a particular sequence of actions. If those actions include an illegal move, return 999999. | def getCostOfActions(self, actions):
if actions == None: return 999999
x, y = self.getStartState()
cost = 0
for action in actions:
# Check figure out the next state and see whether its' legal
dx, dy = Actions.directionToVector(action)
x, y = int(x + dx... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getCostOfActions(self, actions):\n if actions == None: return 999999\n x,y= self.getStartState()\n cost = 0\n for action in actions:\n # Check figure out the next state and see whether its' legal\n dx, dy = Actions.directionToVector(action)\n x, y = ... | [
"0.7820553",
"0.7820553",
"0.78143483",
"0.78090173",
"0.7793637",
"0.778846",
"0.778846",
"0.778846",
"0.7624677",
"0.7528754",
"0.7528754",
"0.750788",
"0.7489202",
"0.7310127",
"0.71119225",
"0.7026165",
"0.6846151",
"0.6645367",
"0.6599338",
"0.65375865",
"0.6534645",
"... | 0.78454506 | 0 |
Stores the walls, pacman's starting position and corners. | def __init__(self, startingGameState):
self.walls = startingGameState.getWalls()
self.startingPosition = startingGameState.getPacmanPosition()
top, right = self.walls.height - 2, self.walls.width - 2
self.corners = ((1, 1), (1, top), (right, 1), (right, top))
for corner in self.c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_walls(self):\n self.wall_list = self.get_current_map().get_layer_by_name(\"Obstacles\").sprite_list",
"def update(self):\n self.center_x += self.change_x\n self.center_y += self.change_y\n\n # boundary for the sides of the screen\n if self.left < 0:\n self.... | [
"0.6553407",
"0.6439267",
"0.6410871",
"0.6165757",
"0.6142492",
"0.61298555",
"0.61298555",
"0.61263794",
"0.6081006",
"0.5944192",
"0.5859338",
"0.5857254",
"0.57709366",
"0.575432",
"0.5740533",
"0.5733998",
"0.5732627",
"0.569977",
"0.56823653",
"0.5681751",
"0.5681751",
... | 0.5416992 | 52 |
Returns the start state (in your state space, not the full Pacman state space) | def getStartState(self):
"*** YOUR CODE HERE ***"
return self.startFoodPosition
# util.raiseNotDefined() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_start_state(self):\n util.raiseNotDefined()",
"def get_start_state(self):\r\n util.raiseNotDefined()",
"def getStartState(self):\n\t\tutil.raiseNotDefined()",
"def getStartState(self):\n\t\tutil.raiseNotDefined()",
"def getStartState(self):\n return self._start_loc",
"def get... | [
"0.7900373",
"0.7881272",
"0.7876114",
"0.7876114",
"0.7836209",
"0.7813632",
"0.7778253",
"0.7778253",
"0.7778253",
"0.7778253",
"0.7778253",
"0.7778253",
"0.7778253",
"0.7778253",
"0.7778253",
"0.774456",
"0.7720636",
"0.7720636",
"0.7720636",
"0.7720636",
"0.7720636",
"0... | 0.73107725 | 56 |
Returns whether this search state is a goal state of the problem. | def isGoalState(self, state):
"*** YOUR CODE HERE ***"
# Utilizaré el método .count del grid, de manera que me contará los trues que haya.
# Cuando no queden trues, ya hemos acabado.
return state[1].count() == 0
# util.raiseNotDefined() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_goal_state(self, state):\n return self._solved_board == state.board",
"def is_goal(self, state: Grid2D.State) -> bool:\n return state.agent_position in self.goals",
"def is_goal(self, state):\n return state in self.goals # Optionally override this!",
"def isGoalState(self, state)... | [
"0.81648874",
"0.8149119",
"0.804305",
"0.7807305",
"0.771411",
"0.771411",
"0.77004784",
"0.77004784",
"0.7656927",
"0.76477385",
"0.7647404",
"0.75857604",
"0.748599",
"0.7446579",
"0.74351174",
"0.7385353",
"0.73555815",
"0.73327357",
"0.7320426",
"0.73087615",
"0.72870225... | 0.74305105 | 15 |
Returns successor states, the actions they require, and a cost of 1. | def getSuccessors(self, state):
successors = []
top, right = self.walls.height - 2, self.walls.width - 2
for action in [Directions.NORTH, Directions.SOUTH, Directions.EAST, Directions.WEST]:
# Add a successor state to the successor list if the action is legal
# Here's a ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def successorStates(self, state):\r\n\r\n successors = []\r\n\r\n for action in Directions.CARDINAL:\r\n x, y = state\r\n dx, dy = Actions.directionToVector(action)\r\n nextx, nexty = int(x + dx), int(y + dy)\r\n\r\n if (not self.walls[nextx][nexty]):\r\n ... | [
"0.69875056",
"0.6748617",
"0.6748617",
"0.6595867",
"0.65359575",
"0.64630675",
"0.64619744",
"0.6455761",
"0.6455761",
"0.6450122",
"0.6432776",
"0.6422064",
"0.64208174",
"0.64180684",
"0.64180684",
"0.64180684",
"0.6412825",
"0.64060354",
"0.63809764",
"0.63629216",
"0.63... | 0.0 | -1 |
Returns the cost of a particular sequence of actions. If those actions include an illegal move, return 999999. This is implemented for you. | def getCostOfActions(self, actions):
if actions == None: return 999999
x, y = self.startingPosition
for action in actions:
dx, dy = Actions.directionToVector(action)
x, y = int(x + dx), int(y + dy)
if self.walls[x][y]: return 999999
return len(actions) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getCostOfActions(self, actions):\n if actions == None: return 999999\n x, y = self.getStartState()\n cost = 0\n for action in actions:\n # Check figure out the next state and see whether its' legal\n dx, dy = Actions.directionToVector(action)\n x, y ... | [
"0.7912567",
"0.7894573",
"0.7894573",
"0.7892286",
"0.7860232",
"0.7848207",
"0.7843637",
"0.7843637",
"0.7843637",
"0.77154154",
"0.75512975",
"0.7548826",
"0.7381445",
"0.71972",
"0.70733166",
"0.68809414",
"0.6711399",
"0.6657395",
"0.663557",
"0.66057223",
"0.6591992",
... | 0.75842506 | 11 |
A heuristic for the CornersProblem that you defined. | def cornersHeuristic(state, problem):
corners = problem.corners # These are the corner coordinates
walls = problem.walls # These are the walls of the maze, as a Grid (game.py)
"*** YOUR CODE HERE ***"
"""
En este ejercicio me he dado cuenta de un problema de mi definición del espacio de estados:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cornersHeuristic(state, problem):\n corners = problem.corners # These are the corner coordinates\n walls = problem.walls # These are the walls of the maze, as a Grid (game.py)\n\t\n util.raiseNotDefined()",
"def cornersHeuristic(state, problem):\n\n # Useful information.\n # corners = proble... | [
"0.76773816",
"0.7427512",
"0.73100895",
"0.6543437",
"0.6530663",
"0.6282049",
"0.61698675",
"0.61315817",
"0.6004433",
"0.60016656",
"0.5962924",
"0.5940898",
"0.593283",
"0.5849472",
"0.5847571",
"0.5844245",
"0.584287",
"0.584087",
"0.5838965",
"0.58175015",
"0.58063775",... | 0.7329421 | 2 |
Returns the cost of a particular sequence of actions. If those actions include an illegal move, return 999999 | def getCostOfActions(self, actions):
x, y = self.getStartState()[0]
cost = 0
for action in actions:
# figure out the next state and see whether it's legal
dx, dy = Actions.directionToVector(action)
x, y = int(x + dx), int(y + dy)
if self.walls[x][y... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getCostOfActions(self, actions):\n if actions == None: return 999999\n x, y = self.getStartState()\n cost = 0\n for action in actions:\n # Check figure out the next state and see whether its' legal\n dx, dy = Actions.directionToVector(action)\n x, y ... | [
"0.79198736",
"0.7901613",
"0.7901613",
"0.78904784",
"0.788902",
"0.7876151",
"0.7876151",
"0.7876151",
"0.7714509",
"0.75729525",
"0.75729525",
"0.7536753",
"0.75249106",
"0.73637825",
"0.7127707",
"0.7030042",
"0.6826243",
"0.6705996",
"0.66891235",
"0.6635452",
"0.6619968... | 0.7892356 | 3 |
Your heuristic for the FoodSearchProblem goes here. This heuristic must be consistent to ensure correctness. First, try to come up with an admissible heuristic; almost all admissible heuristics will be consistent as well. If using A ever finds a solution that is worse uniform cost search finds, your heuristic is not co... | def foodHeuristic(state, problem):
position, foodGrid = state
"*** YOUR CODE HERE ***"
"""
Mi heurística consiste en hacer simplemente el máximo de las distancias reales del state a cada nodo con comida
He provado diferentes heurísticas y esta es la que me expande menos nodos, aunque no es la más óp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def foodHeuristic(state, problem):\n import itertools\n\n\n\n def manhattan(startPosition, targetPosition):\n xy1 = startPosition\n xy2 = targetPosition\n return abs(xy1[0] - xy2[0]) + abs(xy1[1] - xy2[1])\n\n position, foodGrid = state\n\n return len(foodGrid.asList())\n #\n ... | [
"0.83897704",
"0.830523",
"0.8223044",
"0.6986859",
"0.69107854",
"0.6910324",
"0.6817668",
"0.67753005",
"0.6737241",
"0.67104596",
"0.66949224",
"0.66923463",
"0.6692185",
"0.66603684",
"0.66597563",
"0.66365445",
"0.66059625",
"0.6605135",
"0.65819836",
"0.6560537",
"0.652... | 0.85888267 | 0 |
Returns a path (a list of actions) to the closest dot, starting from gameState. | def findPathToClosestDot(self, gameState):
# Here are some useful elements of the startState
startPosition = gameState.getPacmanPosition()
food = gameState.getFood()
walls = gameState.getWalls()
problem = AnyFoodSearchProblem(gameState)
"*** YOUR CODE HERE ***"
r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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 ... | [
"0.7966998",
"0.715944",
"0.7031334",
"0.7026767",
"0.68767905",
"0.6658364",
"0.64656806",
"0.6376818",
"0.6200842",
"0.6165224",
"0.6043223",
"0.60112387",
"0.59972686",
"0.59689665",
"0.5964047",
"0.5963518",
"0.58828336",
"0.5865455",
"0.58330965",
"0.58273715",
"0.580822... | 0.7227898 | 1 |
The state is Pacman's position. Fill this in with a goal test that will complete the problem definition. | def isGoalState(self, state):
x, y = state[0]
"*** YOUR CODE HERE ***"
return self.food[x][y]
# util.raiseNotDefined() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def goal_test(self, state):\n self.numbernodes += 1\n\n i = 0\n for box in state.boxes :\n for coord in self.board.positionGoal :\n if coord[0] == box.y and coord[1] == box.x : \n i+=1\n if i == 0 : return False\n i = 0\n ... | [
"0.67018145",
"0.6565885",
"0.6543021",
"0.6499273",
"0.6493787",
"0.64873224",
"0.6445942",
"0.6436759",
"0.6386426",
"0.63844115",
"0.6348103",
"0.6292585",
"0.6277623",
"0.6226234",
"0.6225019",
"0.62167645",
"0.61972904",
"0.61972904",
"0.61792105",
"0.6155007",
"0.615252... | 0.59515357 | 41 |
Returns the maze distance between any two points, using the search functions you have already built. The gameState can be any game state Pacman's position in that state is ignored. | def mazeDistance(point1, point2, gameState):
x1, y1 = point1
x2, y2 = point2
walls = gameState.getWalls()
assert not walls[x1][y1], 'point1 is a wall: ' + str(point1)
assert not walls[x2][y2], 'point2 is a wall: ' + str(point2)
prob = PositionSearchProblem(gameState, start=point1, goal=point2, w... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mazeDistance(point1, point2, gameState):\n x1, y1 = int(point1[0]),int(point1[1])\n x2, y2 = int(point2[0]),int(point2[1])\n walls = gameState.getWalls()\n \n assert not walls[x1][y1], 'point1 is a wall: ' + point1\n assert not walls[x2][y2], 'point2 is a wall: ' + str(point2)\n prob = Pos... | [
"0.7405596",
"0.62337524",
"0.6202874",
"0.61033416",
"0.60770017",
"0.5981286",
"0.5948442",
"0.5916513",
"0.58608997",
"0.58241653",
"0.5822506",
"0.5700954",
"0.5659414",
"0.5651273",
"0.56431204",
"0.56091815",
"0.5609093",
"0.56061876",
"0.5589039",
"0.5576174",
"0.55667... | 0.7542628 | 1 |
(file open for reading) > query dictionary Read query_file and return information in the query dictionary format. | def process_query(query_file):
query_data = query_file.readlines()
query_dict = {}
x = 1
search_dict = {}
search_dict['username'] = query_data[x].strip('\n')
x += 1
operation_list = []
while query_data[x] != 'FILTER\n':
operation_list.append(query_data[x].strip('... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_query (file):\n\n # initialize all the dictionaries and lists we will be using\n query_data = {}\n query_data ['search'] = {'operations':[]}\n query_data ['filter'] = {}\n query_data ['present'] = {}\n\n temp = ''\n\n file.readline() # for when the file says SEARCH\n\n query_dat... | [
"0.7843726",
"0.7040409",
"0.6731658",
"0.6676415",
"0.65146685",
"0.62667567",
"0.62590575",
"0.6256823",
"0.6215728",
"0.62133837",
"0.61976427",
"0.6147864",
"0.61316043",
"0.61125714",
"0.60755527",
"0.6060231",
"0.6012341",
"0.6004686",
"0.59304434",
"0.5879766",
"0.5842... | 0.80009 | 0 |
(dict, list, str, int) > dict Return a dict with key filter_type of query_data given the index. | def filter_format(filter_dict, query_data, filter_type, index):
filter_list = ''
count = 0
while query_data[index] != 'PRESENT\n':
if filter_type in query_data[index]:
count += 1
filter_keyword = query_data[index].strip(filter_type)
fil... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __index_data_body(index, doc_type, doc_id, source):\n\n index_data = {\n \"_index\": index,\n \"_type\": doc_type,\n \"_id\": doc_id,\n \"_source\": source\n }\n\n return index_data",
"def fetch_querydict(self):\n query = dict()\n ... | [
"0.5705551",
"0.5667574",
"0.5598227",
"0.55603284",
"0.5518409",
"0.5467773",
"0.54619396",
"0.54030484",
"0.53398377",
"0.532923",
"0.5268471",
"0.5182582",
"0.5160404",
"0.51402986",
"0.51049006",
"0.508951",
"0.5088857",
"0.5058746",
"0.50552565",
"0.50269693",
"0.5026853... | 0.65318596 | 0 |
(Twitterverse dictionary, str) > list of str Return a list of all users following twitter_name in twitter_dict. >>> twitter_file = open('data.txt', 'r') >>> twitter_dictionary = process_data(twitter_file) >>> all_followers(twitter_dictionary, 'NicoleKidman') ['PerezHilton', 'q', 'p', 'tomCruise'] >>> twitter_file = ope... | def all_followers(twitter_dict, twitter_name):
following_list = []
for user in twitter_dict:
f_list = twitter_dict[user]['following']
if twitter_name in f_list:
following_list.append(user)
return following_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_followers (twitter_data, username):\n\n # initialize\n followers = []\n\n for key in twitter_data: # go through every username in twitter_data\n if username in twitter_data [key]['following']: # check each 'following'\n followers.append (key)\n\n followers.sort() # sort the li... | [
"0.83895",
"0.7141314",
"0.680105",
"0.6771905",
"0.6646324",
"0.66039145",
"0.6573563",
"0.6453545",
"0.644731",
"0.63955975",
"0.62907255",
"0.62907255",
"0.62907255",
"0.62907255",
"0.6255389",
"0.6255389",
"0.6255389",
"0.62464976",
"0.6245325",
"0.620537",
"0.6181806",
... | 0.8723968 | 0 |
(Twitterverse dictionary, search specification dictionary) > list of str Return a list of users from twitter_dict that fit the specification declared by search_dict. >>> data_file = open('data.txt', 'r') >>> twitter_dict = process_data(data_file) >>> query_file = open('query3.txt', 'r') >>> query_dict = process_query(q... | def get_search_results(twitter_dict, search_dict):
search_list = [search_dict['username']]
search_specified_list = []
for user in search_list:
search_users_list = [user]
for operation in search_dict['operations']:
search_users_list = search_helper(search_user... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_filter_results(twitter_dict, username_list, filter_dict):\r\n twitter_handles = username_list \r\n name_filtered_list = []\r\n upper_user = []\r\n \r\n if 'name_includes' in filter_dict: \r\n for user in twitter_handles: \r\n user = user.upper()\r\n upper_user.ap... | [
"0.67444634",
"0.63622165",
"0.61439055",
"0.5823485",
"0.57738215",
"0.56694967",
"0.56202865",
"0.561638",
"0.5604377",
"0.55924684",
"0.557445",
"0.552582",
"0.5494284",
"0.5484312",
"0.5452842",
"0.53725946",
"0.5361354",
"0.5322175",
"0.5318818",
"0.5298553",
"0.5283197"... | 0.7901854 | 0 |
(list of str, str, twitterverse dictionary) > list of str Return the list of users that result from operation having applied to name_list from the twitter_dict. >>> data_file = open('data.txt', 'r') >>> twitter_dict = process_data(data_file) >>> query_file = open('query3.txt', 'r') >>> query_dict = process_query(query_... | def search_helper(name_list, operation, twitter_dict):
return_list = []
for name in name_list:
if operation == 'following':
search_specified_list = twitter_dict[name]['following']
for following_names in search_specified_list:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_search_results(twitter_dict, search_dict):\r\n\r\n search_list = [search_dict['username']] \r\n search_specified_list = []\r\n\r\n for user in search_list:\r\n search_users_list = [user]\r\n \r\n for operation in search_dict['operations']:\r\n search_users_list = se... | [
"0.7890037",
"0.7527938",
"0.7475859",
"0.7460602",
"0.6427471",
"0.5894421",
"0.5808291",
"0.57747966",
"0.576515",
"0.5687546",
"0.56544125",
"0.5608119",
"0.55629736",
"0.55307204",
"0.54812115",
"0.5464305",
"0.5451584",
"0.5441889",
"0.54186994",
"0.5417747",
"0.540404",... | 0.83645403 | 0 |
(Twitterverse dictionary, list of str, filter specification dictionary) > list of str >>> data_file = open('data.txt', 'r') >>> twitter_dict = process_data(data_file) >>> query_file = open('query2.txt', 'r') >>> query_dict = process_query(query_file) >>> username_list = get_search_results(twitter_dict, search_dict) >>>... | def get_filter_results(twitter_dict, username_list, filter_dict):
twitter_handles = username_list
name_filtered_list = []
upper_user = []
if 'name_includes' in filter_dict:
for user in twitter_handles:
user = user.upper()
upper_user.append(user)
n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_filter_results (twitter_data, search_list, filter_data):\n\n #initialize\n filter_list = []\n\n for operation in filter_data:\n if operation == 'name-includes':\n for username in search_list:\n # since case doesnt matter, eveything is made uppercase and\n ... | [
"0.7434036",
"0.68169296",
"0.63130534",
"0.63128114",
"0.6289486",
"0.6159073",
"0.61330956",
"0.60395426",
"0.6004611",
"0.600197",
"0.5982023",
"0.59766793",
"0.59600365",
"0.59467745",
"0.582324",
"0.58030814",
"0.5769613",
"0.576816",
"0.5756492",
"0.5753108",
"0.5703192... | 0.76796806 | 0 |
(Twitterverse dictionary, list of str, presentation specification dictionary) > str Return final_list of users from twitter_dict in the order and format as indicated by present_dict. >>> data_file = open('data.txt', 'r') >>> twitter_dict = process_data(data_file) >>> query_file = open('query2.txt', 'r') >>> query_dict ... | def get_present_string(twitter_dict, final_list, present_dict):
if present_dict['sort-by'] == 'username':
tweet_sort(twitter_dict, final_list, username_first)
if present_dict['sort-by'] == 'name':
tweet_sort(twitter_dict, final_list, name_first)
if present_di... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_present_string (twitter_data, filter_list, present_data):\n\n #initialize\n present_string = ''\n present_list = filter_list\n\n if present_data ['sort-by'] == 'username':\n tweet_sort (twitter_data, present_list, username_first)\n\n elif present_data ['sort-by'] == 'name':\n t... | [
"0.7329098",
"0.6643551",
"0.6021003",
"0.5802761",
"0.56354165",
"0.5613348",
"0.5397948",
"0.5390319",
"0.538293",
"0.53705984",
"0.5061108",
"0.5039742",
"0.50106114",
"0.49880728",
"0.4931404",
"0.4930936",
"0.49084416",
"0.48675862",
"0.48386815",
"0.48338753",
"0.483336... | 0.77881116 | 0 |
(Twitterverse dictionary, list of str, function) > NoneType Sort the results list using the comparison function cmp and the data in twitter_data. >>> twitter_data = {\ | def tweet_sort(twitter_data, results, cmp):
# Insertion sort
for i in range(1, len(results)):
current = results[i]
position = i
while position > 0 and cmp(twitter_data, results[position - 1], current) > 0:
results[position] = results[position - 1]
pos... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tweet_sort(twitter_data, results, cmp):\n\n # Insertion sort\n for i in range(1, len(results)):\n current = results[i]\n position = i\n while position > 0 and cmp(twitter_data, results[position - 1], current) > 0:\n results[position] = results[position - 1]\n po... | [
"0.7567489",
"0.650274",
"0.6290785",
"0.62436324",
"0.623184",
"0.61069995",
"0.60515857",
"0.59873897",
"0.5878488",
"0.5872183",
"0.58214015",
"0.58214015",
"0.57846797",
"0.5771403",
"0.5755637",
"0.57172424",
"0.5692742",
"0.56895584",
"0.56837285",
"0.56682867",
"0.5616... | 0.76030976 | 0 |
(Twitterverse dictionary, str, str) > int Return 1 if user a has more followers than user b, 1 if fewer followers, and the result of sorting by username if they have the same, based on the data in twitter_data. >>> twitter_data = {\ | def more_popular(twitter_data, a, b):
a_popularity = len(all_followers(twitter_data, a))
b_popularity = len(all_followers(twitter_data, b))
if a_popularity > b_popularity:
return -1
if a_popularity < b_popularity:
return 1
return username_first(twitter_data, a, b) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def more_popular(twitter_data, a, b):\n\n a_popularity = len(all_followers(twitter_data, a))\n b_popularity = len(all_followers(twitter_data, b))\n if a_popularity > b_popularity:\n return -1\n if a_popularity < b_popularity:\n return 1\n return username_first(twitter_data, a, b)",
"... | [
"0.7528208",
"0.69588375",
"0.66971797",
"0.65298504",
"0.6497349",
"0.6357412",
"0.63211817",
"0.6200824",
"0.61589175",
"0.61370516",
"0.61224115",
"0.61210734",
"0.60854435",
"0.6016705",
"0.60084724",
"0.59806305",
"0.5883615",
"0.58259416",
"0.57227236",
"0.5703999",
"0.... | 0.7497807 | 1 |
(Twitterverse dictionary, str, str) > int Return 1 if user a has a username that comes after user b's username alphabetically, 1 if user a's username comes before user b's username, and 0 if a tie, based on the data in twitter_data. >>> twitter_data = {\ | def username_first(twitter_data, a, b):
if a < b:
return -1
if a > b:
return 1
return 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def username_first(twitter_data, a, b):\n\n if a < b:\n return -1\n if a > b:\n return 1\n return 0",
"def name_first(twitter_data, a, b):\n\n a_name = twitter_data[a][\"name\"]\n b_name = twitter_data[b][\"name\"]\n if a_name < b_name:\n return -1\n if a_name > b_name:\... | [
"0.7257887",
"0.7018444",
"0.69511354",
"0.65835136",
"0.6546135",
"0.6383048",
"0.5989066",
"0.5976186",
"0.565109",
"0.56353337",
"0.5623372",
"0.56220394",
"0.56099427",
"0.55019134",
"0.5429901",
"0.5400648",
"0.52955055",
"0.5273156",
"0.527068",
"0.5203552",
"0.5171498"... | 0.7232197 | 1 |
(Twitterverse dictionary, str, str) > int Return 1 if user a's name comes after user b's name alphabetically, 1 if user a's name comes before user b's name, and the ordering of their usernames if there is a tie, based on the data in twitter_data. >>> twitter_data = {\ | def name_first(twitter_data, a, b):
a_name = twitter_data[a]["name"]
b_name = twitter_data[b]["name"]
if a_name < b_name:
return -1
if a_name > b_name:
return 1
return username_first(twitter_data, a, b) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def name_first(twitter_data, a, b):\n\n a_name = twitter_data[a][\"name\"]\n b_name = twitter_data[b][\"name\"]\n if a_name < b_name:\n return -1\n if a_name > b_name:\n return 1\n return username_first(twitter_data, a, b)",
"def username_first(twitter_data, a, b):\n\n if a < b:\n... | [
"0.7261839",
"0.6815641",
"0.67782587",
"0.65419745",
"0.6481994",
"0.6463288",
"0.62870765",
"0.6256376",
"0.5890704",
"0.5813191",
"0.5721417",
"0.57102513",
"0.5625274",
"0.55444145",
"0.5516707",
"0.55118585",
"0.5480974",
"0.5467732",
"0.5466456",
"0.5454952",
"0.5449887... | 0.723645 | 1 |
similar to euclidean_mean_distance but with different parameters and meaning | def euclidean_distance(self, point):
mean = self.mean()
dist = euclidean(mean, point)
radius = self.radius * self.distance_factor()
if radius == 0.0:
# corner case: the ball consists of a single point only
# distance is defined as > 1 for flat dimensions unless po... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _dist(x, y):\n return np.sqrt(np.mean(np.square(x - y)))",
"def dist(mean, example):\n return np.linalg.norm(example.row - mean)",
"def _calculate_mean_distance_theoretical(self):\n\t\tx_mean_distance = 0\n\t\tx_vals,prob_vals = self.tuple_of_probabilities\n\t\tfor i in range(len(x_vals)):\n\t\t\tx_v... | [
"0.67453414",
"0.67426956",
"0.6655829",
"0.6623442",
"0.6519455",
"0.65169704",
"0.64831185",
"0.6479274",
"0.6475939",
"0.6420653",
"0.6352085",
"0.63425595",
"0.6339648",
"0.63304144",
"0.6301134",
"0.62871855",
"0.62703985",
"0.62633747",
"0.62022936",
"0.6182767",
"0.618... | 0.0 | -1 |
Func that get the appropriate table by the message that we get | def get_table_by_text(text: str) -> Dict[str, str]:
for morse_table in MORSE_TABLES:
letter_to_check = _get_first_letter_in_text(text)
if letter_to_check.upper() in morse_table.keys():
return morse_table
if letter_to_check in morse_table.values():
return MORSE_EN_CODE... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_table(table_type):\n if table_type == 'chaining':\n return chaining()\n elif table_type == 'probing':\n return probing()\n elif table_type == 'probing2':\n return probing(probe=2)\n else:\n return robinhood()",
"def get_table(new_arr, types, titles):\n try:\n ... | [
"0.6598475",
"0.6046571",
"0.6041634",
"0.58675545",
"0.5861172",
"0.57853436",
"0.5702748",
"0.5686857",
"0.56158406",
"0.56112516",
"0.55846083",
"0.5560058",
"0.5524576",
"0.5524576",
"0.551431",
"0.5511044",
"0.5503505",
"0.55027205",
"0.54950345",
"0.5490587",
"0.5407383... | 0.5371161 | 22 |
Get the first letter in the message from user if it is not an alpha | def _get_first_letter_in_text(text: str) -> str:
for letter in text:
if letter.isalpha():
return letter
return text[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean_message(message):\n alphabet = ''\n for i in range(len(message)):\n if message[i].isalpha():\n alphabet = alphabet + message[i].upper()\n return alphabet\n # Will obtain a str that will only contain alphabets that are uppercase.",
"def Prints_single_letter_string_when_tryi... | [
"0.7021727",
"0.69095814",
"0.6808512",
"0.67910373",
"0.6768156",
"0.6737975",
"0.67040485",
"0.66168314",
"0.65995246",
"0.65331924",
"0.6513524",
"0.64735717",
"0.6369872",
"0.6368524",
"0.63524103",
"0.6332107",
"0.6301702",
"0.6275444",
"0.6264006",
"0.6255922",
"0.62482... | 0.77461845 | 0 |
Function called when plugin is created. No data should be set to Provider in this function because Location don't have to provide valid location data yet. | def init():
global PLUGIN_NAME
PLUGIN_NAME = inspect.currentframe().f_code.co_filename | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, location):\n self.location = location",
"def location_callback(self,msg):\n self.location = msg.data",
"def __init__(self, location, latitude, longitude, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.location = location\n self.latitude = lati... | [
"0.6313835",
"0.6262843",
"0.62485856",
"0.61801076",
"0.6073936",
"0.60558265",
"0.6055061",
"0.6036741",
"0.5996565",
"0.5970159",
"0.5897557",
"0.5896188",
"0.57455975",
"0.57201284",
"0.570606",
"0.56932735",
"0.5686622",
"0.5674247",
"0.5652441",
"0.5621614",
"0.55897707... | 0.0 | -1 |
Called when plugin data are requested. When this function is called, Location data are valid. In this function should be set data for provider. Data are set with Provider.serProperty(pluginName, key, value) method. This method can by called multiple times, all keys are added to this plugin datasource. At the end, when ... | def request():
Provider.setProperty(PLUGIN_NAME, "Hello!", "You are in %s." %
Location.getCity())
Provider.done(PLUGIN_NAME) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_plugin_data(self, plugin_data):\n self.plugin_data = plugin_data",
"def load_plugin_data(self, data):\n return",
"def plugin_data(self) -> global___SummaryMetadata.PluginData:",
"def save_plugin_data(self):\n return",
"def onRefreshPluginData(self, plugin_name, data):\n ... | [
"0.661341",
"0.6536815",
"0.60909444",
"0.59573627",
"0.5681677",
"0.56695366",
"0.56579214",
"0.5650003",
"0.56410986",
"0.56398",
"0.5607061",
"0.5585324",
"0.5378627",
"0.53782827",
"0.5350443",
"0.53449184",
"0.5344845",
"0.5332154",
"0.53285",
"0.53275234",
"0.53275234",... | 0.0 | -1 |
Convert a Composer checkpoint to a pretrained HF checkpoint folder. Write a ``config.json`` and ``pytorch_model.bin``, like | def write_huggingface_pretrained_from_composer_checkpoint(
checkpoint_path: Union[Path, str],
output_path: Union[Path, str],
output_precision: str = 'fp32',
local_checkpoint_save_location: Optional[Union[Path, str]] = None
) -> Tuple[PretrainedConfig, Optional[PreTrainedTokenizerBase]]:
dtype = {
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_checkpoint(huggingface_model_name_or_path, output_path):\n output_dir, _ = os.path.split(output_path)\n tf.io.gfile.makedirs(output_dir)\n\n huggingface_bert_model, huggingface_bert_config = _get_huggingface_bert_model_and_config(\n huggingface_model_name_or_path)\n encoder = _create_fffner_mo... | [
"0.6353711",
"0.6301693",
"0.63011956",
"0.610833",
"0.6077828",
"0.59906185",
"0.59823364",
"0.59694815",
"0.5962135",
"0.5917442",
"0.59148014",
"0.5914448",
"0.5885656",
"0.58622265",
"0.5843601",
"0.5778996",
"0.5778468",
"0.57622725",
"0.5746577",
"0.57425416",
"0.573442... | 0.66567194 | 0 |
Generate a complex layout report with simple elements | def gen_report_complex_no_files() -> dp.Report:
select = dp.Select(blocks=[md_block, md_block], type=dp.SelectType.TABS)
group = dp.Group(md_block, md_block, columns=2)
return dp.Report(
dp.Page(
blocks=[
dp.Group(md_block, md_block, columns=2),
dp.Select... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _generate_layout(self):\n\n pass",
"def create_layout( self ):",
"def display_reports(self, layout): # pylint: disable=arguments-differ",
"def create_html_layout(self):\n page = \"\"\"<!DOCTYPE html>\n <!doctype html>\n <html lang=\"en\">\n <head>\n <meta c... | [
"0.69769275",
"0.6473278",
"0.63054246",
"0.60292476",
"0.59565306",
"0.5911801",
"0.5869038",
"0.5819134",
"0.57823735",
"0.5755476",
"0.57442385",
"0.56819475",
"0.56775093",
"0.5628919",
"0.56264186",
"0.5593363",
"0.5590153",
"0.5521933",
"0.55100393",
"0.5480658",
"0.543... | 0.67525214 | 1 |
Test case unused atm | def __test_gen_report_id_check():
# all fresh
report = dp.Report(md_block, md_block, md_block)
assert_report(report) # expected_id_count=5)
# 2 fresh
report = dp.Report(md_block, md_block_id, md_block)
assert_report(report) # expected_id_count=4)
# 0 fresh
report = dp.Report(md_block_i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _test(self):\n pass",
"def _test(self):\n pass",
"def _test(self):\n pass",
"def test_4_4_1_1(self):\n pass",
"def _test(self):",
"def _test(self):",
"def _test(self):",
"def _test(self):",
"def _test(self):",
"def test(self):\n pass",
"def test(self):\n ... | [
"0.78134644",
"0.78134644",
"0.78134644",
"0.7711441",
"0.76790416",
"0.76790416",
"0.76790416",
"0.76790416",
"0.76790416",
"0.7488815",
"0.7460914",
"0.7328567",
"0.71997136",
"0.71704173",
"0.7143496",
"0.70497507",
"0.70497507",
"0.7022566",
"0.7022566",
"0.69937253",
"0.... | 0.0 | -1 |
Test TextReport API and id/naming handling | def test_textreport_gen():
s_df = gen_df()
# Simple
report = dp.TextReport("Text-3")
assert_text_report(report, 1)
# multiple blocks
report = dp.TextReport("Text-1", "Text-2", s_df)
assert_text_report(report, 3)
# empty - raise error
with pytest.raises(DPError):
report = d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_basic_usage(self):\n self._test_reports_helper({}, [\"report.txt\"])",
"def run_test_ner():\n # This note is a fake report\n\n text = \"\"\"\nRecord date: 2063-12-13\n\n\n\n\nNAME: Doe, Jane \nMRN: 98765432\n\nThe patient is here as a walk-in. Her spouse is present.\n\nPatient sa... | [
"0.61058956",
"0.59754026",
"0.59663147",
"0.5875179",
"0.5820495",
"0.5816298",
"0.5780176",
"0.56849706",
"0.5683433",
"0.56673104",
"0.56545895",
"0.5620811",
"0.55447906",
"0.552769",
"0.5513816",
"0.55067",
"0.54996467",
"0.549786",
"0.54872155",
"0.5484214",
"0.5477892"... | 0.63549286 | 0 |
| Indicates if SofortBank could estabilish if the transaction could successfully be processed. 0 You should wait for the transaction to be reported as paid before shipping any goods. 1 You can ship the goods. In case the transaction is not reported as paid you can initiate a claims process with SofortBank. | def security_indicator(self):
return self.__security_indicator | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def has_succeeded(self):\n return self.transaction_result == TERMINAL_PAYMENT_SUCCESS",
"def get_success_flag(self):\n return True",
"def is_success(self):\n return self.type_id == STATE_SUCCESS",
"def task_success(self, ref2goal=True):\n # for sit in list(turn_data['final_goal_st... | [
"0.66063505",
"0.6404131",
"0.638745",
"0.63153917",
"0.6293099",
"0.6174246",
"0.614074",
"0.6126725",
"0.60886395",
"0.6074187",
"0.606531",
"0.60510194",
"0.6040676",
"0.6032343",
"0.6032343",
"0.6019132",
"0.5954168",
"0.5939761",
"0.5916004",
"0.58997816",
"0.58165276",
... | 0.0 | -1 |
Set required and widgets for fields. | def __init__(self, *args, **kwargs):
super(SignupForm, self).__init__(*args, **kwargs)
self.fields['email'].required = True
self.fields['first_name'].required = True
self.fields['password'].widget = forms.PasswordInput()
for field in self.fields:
self.fields[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n placeholders = {\n \"first_name\": \"First Name\",\n \"last_name\": \"Last Name\",\n \"default_phone_num\": \"Phone Number\",\n \"default_passport_num\": \"Passport Number\",\n ... | [
"0.6541632",
"0.6453019",
"0.6182293",
"0.613699",
"0.61324316",
"0.61182314",
"0.611023",
"0.6102259",
"0.6014309",
"0.5993374",
"0.5987304",
"0.59669083",
"0.59576404",
"0.59438926",
"0.59405667",
"0.59002674",
"0.58811474",
"0.5862535",
"0.58578044",
"0.58545446",
"0.58465... | 0.6483126 | 1 |
Validate if email is already used by other user. | def clean_email(self):
email = self.cleaned_data['email'].lower()
if User.objects.filter(email__iexact=email).exists():
raise ValidationError(_('A user with that email already exists.'))
return email | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_email(self, email):\n if email.data != current_user.email:\n user = User.query.filter_by(email=email.data).first()\n if user:\n raise ValidationError('That email already exists. Please choose another email.')",
"def clean_email(self):\n try:\n ... | [
"0.7807831",
"0.7748905",
"0.7703968",
"0.77026623",
"0.7623712",
"0.76225734",
"0.75870395",
"0.75870395",
"0.7544878",
"0.75052977",
"0.7495125",
"0.7474632",
"0.7456973",
"0.7412911",
"0.738862",
"0.7304129",
"0.729272",
"0.7292294",
"0.7270725",
"0.72010756",
"0.71731097"... | 0.71971816 | 20 |
Validate password with settings constraints. | def clean_password(self):
password = self.cleaned_data.get('password')
password_validation.validate_password(self.cleaned_data.get('password'), self.instance)
return password | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_password(self, value):\n policy = PasswordPolicy.from_names(\n length=8, # min length: 8\n uppercase=1, # need min. 1 uppercase letter\n numbers=1, # need min. 1 digit\n special=1, # need min. 1 special characters\n nonletters=1,\n ... | [
"0.7843949",
"0.78396183",
"0.76012516",
"0.754959",
"0.75224483",
"0.74456346",
"0.7356819",
"0.7329701",
"0.729943",
"0.7290045",
"0.7280439",
"0.7245891",
"0.7228651",
"0.7214994",
"0.7207353",
"0.7188498",
"0.7177668",
"0.71768767",
"0.7148098",
"0.7129629",
"0.7114455",
... | 0.69429576 | 31 |
Set email and password for new user. | def save(self, commit=True):
user = super(SignupForm, self).save(commit=False)
user.email = self.cleaned_data.get('email')
user.username = self.cleaned_data.get('email')
user.set_password(self.cleaned_data['password'])
if commit:
user.save()
return user | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_user(self, email, password, **extra_fields):\n\n email = self.normalize_email(email)\n #username = self.model.normalize_username(username)\n user = self.model( email=email, **extra_fields)\n user.set_password(password)\n user.save(using=self._db)\n return user"... | [
"0.766087",
"0.7580593",
"0.75752753",
"0.7525016",
"0.7522465",
"0.7521504",
"0.75023276",
"0.74982846",
"0.7490862",
"0.74790376",
"0.74702173",
"0.74702173",
"0.74702173",
"0.7445269",
"0.74423265",
"0.74345076",
"0.7434215",
"0.7425774",
"0.7410549",
"0.73849636",
"0.7378... | 0.7396652 | 19 |
Set required and widgets for fields. | def __init__(self, *args, **kwargs):
super(ProfileForm, self).__init__(*args, **kwargs)
for field in self.fields:
self.fields[field].widget.attrs.update(
{
'class': 'form-control',
}
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n placeholders = {\n \"first_name\": \"First Name\",\n \"last_name\": \"Last Name\",\n \"default_phone_num\": \"Phone Number\",\n \"default_passport_num\": \"Passport Number\",\n ... | [
"0.6541632",
"0.6483126",
"0.6453019",
"0.6182293",
"0.613699",
"0.61324316",
"0.61182314",
"0.611023",
"0.6102259",
"0.6014309",
"0.5993374",
"0.5987304",
"0.59669083",
"0.59576404",
"0.59438926",
"0.59405667",
"0.59002674",
"0.58811474",
"0.5862535",
"0.58578044",
"0.585454... | 0.57386833 | 26 |
Set required and widgets for fields. | def __init__(self, *args, **kwargs):
super(CustomAuthenticationForm, self).__init__(*args, **kwargs)
for field in self.fields:
self.fields[field].widget.attrs.update(
{
'class': 'form-control',
}
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n placeholders = {\n \"first_name\": \"First Name\",\n \"last_name\": \"Last Name\",\n \"default_phone_num\": \"Phone Number\",\n \"default_passport_num\": \"Passport Number\",\n ... | [
"0.6541632",
"0.6483126",
"0.6453019",
"0.6182293",
"0.613699",
"0.61324316",
"0.61182314",
"0.611023",
"0.6102259",
"0.6014309",
"0.5993374",
"0.5987304",
"0.59669083",
"0.59576404",
"0.59438926",
"0.59405667",
"0.59002674",
"0.58811474",
"0.5862535",
"0.58578044",
"0.585454... | 0.5717068 | 27 |
Create the sh script for starting unblur | def create_sh_script(
unblur_path, input_image, output_dir,
input_dir, input_suffix, options
):
strSh = ''
# To make sure it is a bash script
strSh += '#!/bin/bash\n\n'
# Export number of threads
strSh += 'export OMP_NUM_THREADS={:d}\n'.forma... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n parser = make_arg_parser()\n if len(sys.argv) == 1:\n parser.print_help()\n sys.exit(1)\n args = parser.parse_args()\n deblur_transcripts(args.input, args.cds_fa, args.vblur, args.output)",
"def launchgui(image):\n from filter import launch\n launch(image)",
"def r... | [
"0.6045751",
"0.54544467",
"0.5439029",
"0.534224",
"0.53305626",
"0.5258778",
"0.52516085",
"0.5213264",
"0.5197605",
"0.51781684",
"0.51781684",
"0.51781684",
"0.51781684",
"0.51781684",
"0.51781684",
"0.51781684",
"0.51781684",
"0.51781684",
"0.51781684",
"0.51781684",
"0.... | 0.6334928 | 0 |
Creates a dictionary that maps domains to encoded ids. | def _get_domain_mappings(domain_to_intents: Dict) -> Dict:
domain2id = {}
domains = list(domain_to_intents)
for index, domain in enumerate(domains):
domain2id[domain] = index
return domain2id | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_intent_mappings(domain_to_intents: Dict) -> Dict:\n domain_to_intent2id = {}\n for domain in domain_to_intents:\n intent_labels = {}\n for index, intent in enumerate(domain_to_intents[domain]):\n intent_labels[intent] = index\n domain_to_intent... | [
"0.68493307",
"0.6190228",
"0.6138264",
"0.6116921",
"0.61143875",
"0.59695417",
"0.5882584",
"0.58567834",
"0.5835327",
"0.58119893",
"0.5768381",
"0.5751803",
"0.5672121",
"0.56632924",
"0.564285",
"0.56324285",
"0.5624405",
"0.56145364",
"0.5583475",
"0.557813",
"0.556828"... | 0.7636259 | 0 |
Creates a dictionary that maps intents to encoded ids. | def _get_intent_mappings(domain_to_intents: Dict) -> Dict:
domain_to_intent2id = {}
for domain in domain_to_intents:
intent_labels = {}
for index, intent in enumerate(domain_to_intents[domain]):
intent_labels[intent] = index
domain_to_intent2id[domain]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_intent_token_dict(intents, intent_split_symbol):\r\n\r\n distinct_tokens = set([token\r\n for intent in intents\r\n for token in intent.split(\r\n intent_split_symbol)])\r\n return {token: i... | [
"0.6695217",
"0.64867634",
"0.6394871",
"0.60963374",
"0.59980714",
"0.5829211",
"0.5791798",
"0.57791173",
"0.56940323",
"0.5672877",
"0.56094426",
"0.5583357",
"0.55793476",
"0.55350786",
"0.5458744",
"0.5416988",
"0.538743",
"0.5383223",
"0.5371814",
"0.53664494",
"0.53332... | 0.7101111 | 0 |
Generates index mapping for entity labels in an application. Supports both BIO and BIOES tag schemes. | def _get_entity_mappings(query_list: ProcessedQueryList) -> Dict:
entity_labels = set()
logger.info("Generating Entity Labels...")
for d, i, entities in zip(
query_list.domains(), query_list.intents(), query_list.entities()
):
if len(entities):
for... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def label_map_gen(df_main):\n # Function to flatten a list of list\n flatten = lambda l: [item for sublist in l for item in sublist]\n labels = list(set(flatten([l.split(' ') for l in df_main['tags'].values])))\n\n # Create list of labels\n label_map = {l: i for i, l in enumerate(labels)}\n retur... | [
"0.6224174",
"0.59211826",
"0.58924776",
"0.57814723",
"0.5704783",
"0.56490207",
"0.5625467",
"0.56178284",
"0.54621464",
"0.5448301",
"0.5429293",
"0.5419123",
"0.5365201",
"0.5340245",
"0.53379524",
"0.53297305",
"0.52976096",
"0.5295537",
"0.5263942",
"0.52478415",
"0.523... | 0.5245018 | 20 |
Creates a class label for a set of queries. These labels are used to split queries by type. Labels follow the format of "domain" or "domain|intent". For example, "date|get_date". | def get_class_labels(
tuning_level: list, query_list: ProcessedQueryList
) -> List[str]:
if TuneLevel.INTENT.value in tuning_level:
return [
f"{d}.{i}" for d, i in zip(query_list.domains(), query_list.intents())
]
else:
return [f"{d}" for d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_label(termtype, timeperiod):\n label = 'Graph these comma-separated noun phrases (yearly frequencies):' if termtype == 'Noun phrases' and timeperiod == 'Yearly' \\\n else 'Graph these comma-separated noun phrases (monthly frequencies):' if termtype == 'Noun phrases' and timeperiod == 'Monthly... | [
"0.6051387",
"0.5911016",
"0.58429545",
"0.5480097",
"0.54685163",
"0.5401774",
"0.5383226",
"0.5366071",
"0.5278606",
"0.5277043",
"0.5194852",
"0.5194105",
"0.51914555",
"0.51535213",
"0.5120259",
"0.5098108",
"0.50675786",
"0.5051951",
"0.50454336",
"0.50446814",
"0.503565... | 0.62765896 | 0 |
Creates a label map. | def create_label_map(app_path, file_pattern):
resource_loader = ResourceLoader.create_resource_loader(app_path)
query_tree = resource_loader.get_labeled_queries(label_set=file_pattern)
return LabelMap(query_tree) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_labels_and_mapping(self, labels, mapping):\n numbered_classes = list(enumerate(list(labels), start=0))\n if mapping:\n new_mapping = {number: str(mapping[label]) for number, label in numbered_classes}\n else:\n new_mapping = {number: str(label) for number, lab... | [
"0.7576466",
"0.74621993",
"0.73188335",
"0.71555984",
"0.7096146",
"0.6969032",
"0.6945365",
"0.69231826",
"0.6836402",
"0.68079114",
"0.68001956",
"0.67257994",
"0.65746284",
"0.65047145",
"0.6429039",
"0.6415675",
"0.63368577",
"0.627749",
"0.6263282",
"0.62631065",
"0.625... | 0.64313173 | 14 |
This class loads data as processed queries from a specified log file. | def __init__(self, app_path: str, tuning_level: list, log_file_path: str):
self.app_path = app_path
self.tuning_level = tuning_level
self.log_file_path = log_file_path | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(logFile):\n pass #TODO",
"def _ProcessLog(self, log_processor, logfile): # pylint: disable=R0201\n for line in open(os.path.join(self.data_directory, logfile)):\n log_processor.ProcessLine(line)",
"def process_log_file(cur, filepath):\n \n # open log file\n df = pd.read_json(fil... | [
"0.6776109",
"0.6508564",
"0.64269346",
"0.63747877",
"0.6232887",
"0.6207779",
"0.60483116",
"0.6015258",
"0.6014473",
"0.598701",
"0.59513843",
"0.5894735",
"0.5886366",
"0.58820903",
"0.5859833",
"0.58380693",
"0.5823934",
"0.58144087",
"0.5813929",
"0.58069664",
"0.579026... | 0.0 | -1 |
Removes duplicates in the text queries. | def deduplicate_raw_text_queries(log_queries_iter) -> List[str]:
return list(set(q for q in log_queries_iter)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _remove_duplicates(self):\n self.search_query = remove_duplicates(self.search_query)",
"def remove_duplicates(self, hits):\n\t\tseen = set()\n\t\tkeep = []\n\n\t\tfor i in range(len(hits)):\n\t\t\tif hits[i][\"Text\"] not in seen:\n\t\t\t\tseen.add(hits[i][\"Text\"])\n\t\t\t\tkeep.append(hits[i])\n\n\... | [
"0.7845041",
"0.6695697",
"0.6653341",
"0.65625846",
"0.639675",
"0.6349758",
"0.6328951",
"0.6103831",
"0.6063389",
"0.60107267",
"0.59329724",
"0.5881362",
"0.58800447",
"0.5849684",
"0.5797378",
"0.5773862",
"0.5744445",
"0.57247037",
"0.56726134",
"0.5653875",
"0.562954",... | 0.76712906 | 1 |
Converts text queries to processed queries using an annotator. | def convert_text_queries_to_processed(
self, text_queries: List[str]
) -> List[ProcessedQuery]:
logger.info("Loading a Bootstrap Annotator to process log queries.")
annotator_params = DEFAULT_AUTO_ANNOTATOR_CONFIG
annotator_params["app_path"] = self.app_path
bootstrap_annotat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_analysis(self, query, key=None):\n logger.info(\"Running analysis on query...\")\n core_annotation = Annotation(query, key)\n clf_pipeline = AnalysisPipeline()\n entity_pipeline = AnalysisPipeline()\n clf = self.clf_accessor.get_classification_pipeline('multiclass', 'inte... | [
"0.58529824",
"0.5585822",
"0.5577068",
"0.55282134",
"0.5404479",
"0.53600365",
"0.53220135",
"0.52643645",
"0.52558595",
"0.5248043",
"0.52073747",
"0.5193515",
"0.51917845",
"0.5176019",
"0.5160177",
"0.50877666",
"0.5071344",
"0.50710976",
"0.50638235",
"0.5001331",
"0.49... | 0.70313007 | 0 |
Method to get multiple queries from the QueryCache given a list of query ids. | def get_queries(self, query_ids):
return [
self.resource_loader.query_cache.get(query_id) for query_id in query_ids
] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def query_many(self, queries):\n assert isinstance(queries, list)\n cursor = self._cursor()\n results = []\n for query in queries:\n try:\n cursor.execute(query)\n result = cursor.fetchall()\n except Exception as e:\n pr... | [
"0.722569",
"0.65023124",
"0.64487207",
"0.64159083",
"0.6410242",
"0.635374",
"0.62091815",
"0.6204514",
"0.6176422",
"0.6157128",
"0.61314714",
"0.606496",
"0.59988225",
"0.5957463",
"0.5924632",
"0.5920572",
"0.5903233",
"0.58550835",
"0.5850858",
"0.58000696",
"0.57887274... | 0.8206793 | 0 |
Update the current set of sampled queries by adding the set of newly sampled queries. A new PrcoessedQueryList object is created with the updated set of query ids. | def update_sampled_queries(self, newly_sampled_queries_ids):
sampled_queries_ids = self.sampled_queries.elements + newly_sampled_queries_ids
self.sampled_queries = ProcessedQueryList(
cache=self.resource_loader.query_cache, elements=sampled_queries_ids
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_unsampled_queries(self, remaining_indices):\n remaining_queries_ids = [\n self.unsampled_queries.elements[i] for i in remaining_indices\n ]\n self.unsampled_queries = ProcessedQueryList(\n cache=self.resource_loader.query_cache, elements=remaining_queries_ids\n... | [
"0.68086916",
"0.5676029",
"0.5447187",
"0.5287999",
"0.5281685",
"0.5269392",
"0.5163817",
"0.50805366",
"0.5080143",
"0.50727624",
"0.50701463",
"0.50502145",
"0.50495815",
"0.5037603",
"0.5023451",
"0.4994067",
"0.49848914",
"0.49457482",
"0.49016884",
"0.48877212",
"0.488... | 0.83345515 | 0 |
Update the current set of unsampled queries by removing the set of newly sampled queries. A new PrcoessedQueryList object is created with the updated set of query ids. | def update_unsampled_queries(self, remaining_indices):
remaining_queries_ids = [
self.unsampled_queries.elements[i] for i in remaining_indices
]
self.unsampled_queries = ProcessedQueryList(
cache=self.resource_loader.query_cache, elements=remaining_queries_ids
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_sampled_queries(self, newly_sampled_queries_ids):\n sampled_queries_ids = self.sampled_queries.elements + newly_sampled_queries_ids\n self.sampled_queries = ProcessedQueryList(\n cache=self.resource_loader.query_cache, elements=sampled_queries_ids\n )",
"def clearpredic... | [
"0.75596094",
"0.5790968",
"0.5650789",
"0.55124557",
"0.5401627",
"0.53630894",
"0.5264245",
"0.5239242",
"0.5194279",
"0.5116806",
"0.50995237",
"0.50639457",
"0.5062219",
"0.49259344",
"0.4909404",
"0.4904073",
"0.48995757",
"0.48682117",
"0.48384356",
"0.48304084",
"0.482... | 0.7108111 | 1 |
Method to sample a DataBucket's unsampled_queries and update its sampled_queries and newly_sampled_queries. | def sample_and_update(
self,
sampling_size: int,
confidences_2d: List[List[float]],
confidences_3d: List[List[List[float]]],
heuristic: Heuristic,
confidence_segments: Dict = None,
tuning_type: TuningType = TuningType.CLASSIFIER,
):
if tuning_type == ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_sampled_queries(self, newly_sampled_queries_ids):\n sampled_queries_ids = self.sampled_queries.elements + newly_sampled_queries_ids\n self.sampled_queries = ProcessedQueryList(\n cache=self.resource_loader.query_cache, elements=sampled_queries_ids\n )",
"def update_unsa... | [
"0.7476263",
"0.683936",
"0.55779433",
"0.53435713",
"0.5312937",
"0.5255059",
"0.52298653",
"0.51839805",
"0.515455",
"0.5151065",
"0.51435345",
"0.5071322",
"0.5067455",
"0.50468653",
"0.5040171",
"0.50190806",
"0.5019019",
"0.5006471",
"0.499834",
"0.49799365",
"0.4929359"... | 0.54295814 | 3 |
Filter queries for training preperation. | def filter_queries_by_nlp_component(
query_list: ProcessedQueryList, component_type: str, component_name: str
):
filtered_queries = []
filtered_queries_indices = []
for index, query in enumerate(query_list.processed_queries()):
if getattr(query, component_type) == compon... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pre_filter(self, qs):\n return qs",
"def filter_query(self, query, request, resource):\n raise NotImplementedError()",
"def filter_query(self, request, query, view):\n raise NotImplementedError('.filter_query() must be implemented.') # pragma: no cover",
"def _custom_filter(self, qu... | [
"0.6468298",
"0.6155105",
"0.61386013",
"0.6082538",
"0.6041894",
"0.60124743",
"0.5988044",
"0.5880612",
"0.5872636",
"0.58634984",
"0.5804566",
"0.5785709",
"0.5770729",
"0.56347954",
"0.562477",
"0.5616445",
"0.56004584",
"0.55968624",
"0.5573194",
"0.5567288",
"0.5564817"... | 0.0 | -1 |
Creates a DataBucket to be used for strategy tuning. | def get_data_bucket_for_strategy_tuning(
app_path: str,
tuning_level: list,
train_pattern: str,
test_pattern: str,
train_seed_pct: float,
):
label_map = LabelMap.create_label_map(app_path, train_pattern)
resource_loader = ResourceLoader.create_resource_loader(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_bucket() -> None:\n try:\n client.make_bucket(DATASETS_BUCKET)\n except BucketAlreadyOwnedByYou:\n logger.debug(f\"Not creating bucket {DATASETS_BUCKET}: Bucket already exists\")\n pass\n else:\n logger.debug(f\"Successfully created bucket {DATASETS_BUCKET}\")",
"d... | [
"0.66712546",
"0.64462686",
"0.6387001",
"0.63800037",
"0.6142138",
"0.6073936",
"0.6030172",
"0.59908855",
"0.59375703",
"0.59357345",
"0.5933943",
"0.5915313",
"0.59029347",
"0.58879966",
"0.58430094",
"0.57862043",
"0.57170695",
"0.5711254",
"0.56925535",
"0.56899697",
"0.... | 0.6229102 | 4 |
Creates a DataBucket to be used for log query selection. | def get_data_bucket_for_query_selection(
app_path: str,
tuning_level: list,
train_pattern: str,
test_pattern: str,
unlabeled_logs_path: str,
labeled_logs_pattern: str = None,
log_usage_pct: float = AL_MAX_LOG_USAGE_PCT,
):
label_map = LabelMap.create_l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_bucket() -> None:\n try:\n client.make_bucket(DATASETS_BUCKET)\n except BucketAlreadyOwnedByYou:\n logger.debug(f\"Not creating bucket {DATASETS_BUCKET}: Bucket already exists\")\n pass\n else:\n logger.debug(f\"Successfully created bucket {DATASETS_BUCKET}\")",
"d... | [
"0.67508155",
"0.6295921",
"0.62482023",
"0.62026525",
"0.6182254",
"0.61577547",
"0.59622437",
"0.5957801",
"0.5936315",
"0.5883336",
"0.5852739",
"0.5831283",
"0.58034855",
"0.5784298",
"0.57722795",
"0.57370543",
"0.5728525",
"0.56832904",
"0.5631121",
"0.5600316",
"0.5600... | 0.52690667 | 47 |
Establish http routes for the given list of routes containing tuples of the form (route, handler object) | def make_routes(routelist):
return webapp2.WSGIApplication(routelist, debug=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def routes():\n import urllib.request, urllib.parse, urllib.error\n output = []\n for rule in app.url_map.iter_rules():\n options = {}\n for arg in rule.arguments:\n options[arg] = \"[{0}]\".format(arg)\n methods = ','.join(rule.methods)\n url = url_for(rule.endpoint... | [
"0.65212214",
"0.64429027",
"0.62730944",
"0.61776197",
"0.61614925",
"0.60371983",
"0.60076576",
"0.5969171",
"0.5950606",
"0.5946168",
"0.59317756",
"0.5844661",
"0.58265465",
"0.5787878",
"0.57873255",
"0.57807803",
"0.57449365",
"0.5722084",
"0.5693369",
"0.5688424",
"0.5... | 0.6722308 | 0 |
Replaces all of the ultisnips variables with the corresponding vscode | def _replace_variables(self, string):
conversions = {"VISUAL": "TM_SELECTED_TEXT"}
for old, new in conversions.items():
string = string.replace(old, new)
return string | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def replace_variables(self, text, context):\n text = text.replace('__VENV_DIR__', context.env_dir)\n text = text.replace('__VENV_NAME__', context.env_name)\n text = text.replace('__VENV_PROMPT__', context.prompt)\n text = text.replace('__VENV_BIN_NAME__', context.bin_name)\n text... | [
"0.6394522",
"0.58065987",
"0.5606063",
"0.5557312",
"0.54911727",
"0.5431594",
"0.5424897",
"0.5397946",
"0.5366627",
"0.5284732",
"0.52125996",
"0.51902866",
"0.5151045",
"0.51302266",
"0.5101047",
"0.5086249",
"0.5032191",
"0.50283474",
"0.5023271",
"0.5014109",
"0.5012332... | 0.6078713 | 1 |
Parses out the snippets into JSON form with the following schema { | def parse_snippet(self, ultisnip_file: Path) -> dict:
snippets_dictionary = {}
with open(ultisnip_file, "r") as f:
for line in f:
if line.startswith("snippet"):
snippet = {}
prefix = line.split()[1].strip()
snippet["... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def snippet_list(request):\n if request.method == 'GET':\n quickstart = Quickstart.objects.all()\n serializer = QuickstartSerializer(snippets, many=True)\n return JsonResponse(serializer.data, safe=False)\n\n elif request.method == 'POST':\n data = JSONParser().parse(request)\n ... | [
"0.6311338",
"0.6069845",
"0.59527874",
"0.5810302",
"0.5810302",
"0.5762867",
"0.57340497",
"0.55275506",
"0.54961646",
"0.5488228",
"0.5488193",
"0.54133624",
"0.5376377",
"0.533812",
"0.5299759",
"0.5267433",
"0.52651376",
"0.52602667",
"0.5223165",
"0.51634073",
"0.515207... | 0.63587433 | 0 |
This function gets the trial sets for each leaf node in this graph. | def get_trial_sets(graph, leaves, diff = 2):
trialsets = {}
for leaf in leaves:
parents = get_parent_path(graph, leaf)
psizes = [len(graph.node[p]['leaves']) for p in parents]
root = parents[-1]
l1id = 1
while l1id < len(parents) -1 and psizes[l1id] < 5:
l1id... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_all_roots(trial):\r\n root_nodes = trial.node_map[0].children.copy()\r\n shuffle(root_nodes)\r\n states = []\r\n for node in root_nodes:\r\n trial_copy = copy.deepcopy(trial)\r\n states.append(trial_copy)\r\n node.observe()\r\n trial_copy = copy.deepcopy(trial)\r\n ... | [
"0.6844502",
"0.6840591",
"0.6083935",
"0.5979716",
"0.59425783",
"0.5910932",
"0.5865636",
"0.5863153",
"0.5837333",
"0.5722749",
"0.57013834",
"0.56999",
"0.5659051",
"0.5631628",
"0.5579923",
"0.5571343",
"0.55593115",
"0.55593115",
"0.55299985",
"0.54905343",
"0.5464976",... | 0.7629318 | 0 |
generate a trial from the given trialset and image maps | def generate_trial(trialset, synset2img, trialtype, num_imgs):
# randomly shuffle the sets.
for s in trialset:
random.shuffle(s)
source = trialset[trialtype]
# sample images
# make sure we have the most specific guy
src_imgs = [random.choice(synset2img[trialset[0][0]])]
for i in rang... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stim_generate(params,stim_list,train):\n if train:\n stim = list(stim_list.keys())\n shuffled_stim = shuffled_images = []\n #for each run get equal amounts of stim and shuffle\n #can only work if 'trials_per_run' is divisible by number of stims\n for run in range(params['r... | [
"0.6116985",
"0.6031568",
"0.5918441",
"0.5664884",
"0.5622315",
"0.5615459",
"0.5599443",
"0.5529613",
"0.55038154",
"0.54847896",
"0.5482034",
"0.5451923",
"0.5441349",
"0.5423713",
"0.5408815",
"0.5383447",
"0.5371646",
"0.5351493",
"0.53448683",
"0.5335508",
"0.52934724",... | 0.7455843 | 0 |
Calculates the fuzzy match of needle in haystack, using a modified version of the Levenshtein distance algorithm. The function is modified from the levenshtein function in the bktree module by Adam Hupp | def __fuzzy_substring(needle, haystack):
m, n = len(needle), len(haystack)
# base cases
if m == 1:
# return not needle in haystack
row = [len(haystack)] * len(haystack)
row[haystack.find(needle)] = 0
return row
if not n:
return m
row1 = [0] * (n + 1)
for... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def levenshtein_normalised(str1, str2):\n\treturn levenshtein(str1, str2, normalise=True)",
"def levenshtein(str1, str2, normalise=False):\n\ttmp = Levenshtein.distance(str1, str2)\n\tif(normalise) and (len(str1) + len(str2)): tmp /= max(len(str1), len(str2))\n\treturn tmp",
"def get_closest_levenshtein(word, ... | [
"0.65816826",
"0.64453566",
"0.6444688",
"0.64391017",
"0.63947976",
"0.63769424",
"0.63476413",
"0.6301144",
"0.6251837",
"0.61857057",
"0.6146241",
"0.6121829",
"0.6104246",
"0.6104119",
"0.607645",
"0.60713935",
"0.6024334",
"0.60240644",
"0.60073864",
"0.5990242",
"0.5945... | 0.66017675 | 0 |
TypesConsoleCertificateSettings a model defined in OpenAPI | def __init__(self, check_revocation=None, console_ca_cert=None, console_custom_cert=None, hpkp=None, local_vars_configuration=None): # noqa: E501 # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration.get_default_copy()
self.local_vars_configuration = lo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self.swagger_types = {\n 'id_conta': 'int',\n 'id_pessoa': 'int',\n 'id_cartao': 'int',\n 'id_bandeira': 'int',\n 'id_tipo_cartao': 'int',\n 'numero_cartao': 'str',\n 'nome_plastico': 'str',\n 'cvv2... | [
"0.51528734",
"0.49188662",
"0.48297343",
"0.4826368",
"0.4826368",
"0.48228797",
"0.4819829",
"0.47996086",
"0.4773806",
"0.4751501",
"0.47396463",
"0.4729209",
"0.47166255",
"0.4694356",
"0.46928954",
"0.46187517",
"0.46133664",
"0.46113682",
"0.4605297",
"0.46039793",
"0.4... | 0.0 | -1 |
Sets the check_revocation of this TypesConsoleCertificateSettings. | def check_revocation(self, check_revocation):
self._check_revocation = check_revocation | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_compatibility_check(check_status):\r\n if Config.loaded:\r\n raise Exception(\"compatibility_check must be set before before \" \\\r\n \"using any other functionalities in libclang.\")\r\n\r\n Config.compatibility_check = check_status",
"def svn_client_... | [
"0.50971395",
"0.45247346",
"0.4501634",
"0.44256946",
"0.43760172",
"0.43499175",
"0.43033206",
"0.42995754",
"0.42879218",
"0.42419428",
"0.42351454",
"0.42196298",
"0.41943878",
"0.41834015",
"0.4180629",
"0.4163931",
"0.4148873",
"0.41426238",
"0.41319498",
"0.41168395",
... | 0.7481139 | 0 |
Sets the console_ca_cert of this TypesConsoleCertificateSettings. | def console_ca_cert(self, console_ca_cert):
self._console_ca_cert = console_ca_cert | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ca_cert(self, ca_cert):\n\n self._ca_cert = ca_cert",
"def console_custom_cert(self, console_custom_cert):\n\n self._console_custom_cert = console_custom_cert",
"def ca_cert_path(self, ca_cert_path: str):\n\n self._ca_cert_path = ca_cert_path",
"def save_ca():\n cert_file = os... | [
"0.68265325",
"0.65130776",
"0.6440239",
"0.58595866",
"0.5228995",
"0.5037131",
"0.5037131",
"0.5013002",
"0.490777",
"0.48871157",
"0.48593655",
"0.48507708",
"0.48467252",
"0.4803529",
"0.48032707",
"0.47784925",
"0.4713782",
"0.46828216",
"0.46399626",
"0.4594442",
"0.456... | 0.85301137 | 0 |
Sets the console_custom_cert of this TypesConsoleCertificateSettings. | def console_custom_cert(self, console_custom_cert):
self._console_custom_cert = console_custom_cert | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def console_ca_cert(self, console_ca_cert):\n\n self._console_ca_cert = console_ca_cert",
"def set_custom_property(self, sNewVmCustomProperty):\n\t\tcall_sdk_function('PrlVmCfg_SetCustomProperty', self.handle, sNewVmCustomProperty)",
"def custom_compliance_domain(self, custom_compliance_domain):\n\n ... | [
"0.6610284",
"0.54055816",
"0.53626394",
"0.52227587",
"0.51395243",
"0.5006331",
"0.49909642",
"0.4988925",
"0.49661958",
"0.49389002",
"0.49314305",
"0.49158552",
"0.489311",
"0.4870659",
"0.48248613",
"0.4814451",
"0.47850242",
"0.4669491",
"0.460155",
"0.4534467",
"0.4508... | 0.8813465 | 0 |
Sets the hpkp of this TypesConsoleCertificateSettings. | def hpkp(self, hpkp):
self._hpkp = hpkp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pssh(self, pssh):\n self._pssh = pssh\n return self",
"def hdp_version(self, hdp_version):\n\n self._hdp_version = hdp_version",
"def set_kp():\n kp = request.params.get(\"kp\", 0, type=float)\n pid = request.params.get(\"pid\", 1, type=int)\n retval = RP_LIB.rp_PIDSetKp(pid, ... | [
"0.56403214",
"0.5224331",
"0.5040199",
"0.50149983",
"0.48443633",
"0.48201424",
"0.48000458",
"0.4754778",
"0.47419602",
"0.4728604",
"0.46491504",
"0.45619443",
"0.45580828",
"0.45580828",
"0.45580828",
"0.4547807",
"0.4547807",
"0.4547807",
"0.4473194",
"0.4460671",
"0.44... | 0.7709247 | 0 |
Returns the model properties as a dict | def to_dict(self, serialize=False):
result = {}
def convert(x):
if hasattr(x, "to_dict"):
args = getfullargspec(x.to_dict).args
if len(args) == 1:
return x.to_dict()
else:
return x.to_dict(serialize)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_dict(self):\n return self.properties",
"def to_dict(self):\n return self.properties",
"def get_properties(self):\n return self.properties",
"def asdict(self):\n return self._prop_dict",
"def json(self):\n rv = {\n prop: getattr(self, prop)\n f... | [
"0.7751993",
"0.7751993",
"0.73391134",
"0.7334895",
"0.7297356",
"0.727818",
"0.7159078",
"0.71578115",
"0.71494967",
"0.71494967",
"0.71283495",
"0.71275014",
"0.7122587",
"0.71079814",
"0.7060394",
"0.7043251",
"0.7034103",
"0.70233124",
"0.69635814",
"0.69586295",
"0.6900... | 0.0 | -1 |
Returns the string representation of the model | def to_str(self):
return pprint.pformat(self.to_dict()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n return super().__str__() + self.model.__str__()",
"def __str__(self) -> str:\n # noinspection PyUnresolvedReferences\n opts = self._meta\n if self.name_field:\n result = str(opts.get_field(self.name_field).value_from_object(self))\n else:\n ... | [
"0.8585678",
"0.7814723",
"0.77902746",
"0.7750817",
"0.7750817",
"0.7713574",
"0.7699132",
"0.7670784",
"0.76510423",
"0.7600937",
"0.7582941",
"0.7570682",
"0.75406617",
"0.75233835",
"0.75168735",
"0.75013274",
"0.74877244",
"0.74877244",
"0.74700385",
"0.7451798",
"0.7446... | 0.0 | -1 |
For `print` and `pprint` | def __repr__(self):
return self.to_str() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pprint(*args, **kwargs):\n if PRINTING:\n print(*args, **kwargs)",
"def print_out():\n pass",
"def custom_print(*objects):\n print(*objects, sep=OFS, end=ORS)",
"def _print(self, *args):\n return _ida_hexrays.vd_printer_t__print(self, *args)",
"def _printable(self):\n ... | [
"0.75577617",
"0.73375154",
"0.6986672",
"0.698475",
"0.6944995",
"0.692333",
"0.6899106",
"0.6898902",
"0.68146646",
"0.6806209",
"0.6753795",
"0.67497987",
"0.6744008",
"0.6700308",
"0.6691256",
"0.6674591",
"0.6658083",
"0.66091245",
"0.6606931",
"0.6601862",
"0.6563738",
... | 0.0 | -1 |
Returns true if both objects are equal | def __eq__(self, other):
if not isinstance(other, TypesConsoleCertificateSettings):
return False
return self.to_dict() == other.to_dict() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __eq__(self, other):\n return are_equal(self, other)",
"def __eq__(self, other):\n return are_equal(self, other)",
"def __eq__(self,other):\n try: return self.object==other.object and isinstance(self,type(other))\n except: return False",
"def __eq__(self, other):\n if i... | [
"0.8088132",
"0.8088132",
"0.8054589",
"0.7982687",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
... | 0.0 | -1 |
Returns true if both objects are not equal | def __ne__(self, other):
if not isinstance(other, TypesConsoleCertificateSettings):
return True
return self.to_dict() != other.to_dict() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __ne__(self, other: object) -> bool:\n if self.__eq__(other):\n return False\n return True",
"def __ne__(self, other: object) -> bool:\n return not self.__eq__(other)",
"def __ne__(self, other) -> bool:\n return not self.__eq__(other)",
"def __eq__(self, other):\n ... | [
"0.845611",
"0.8391477",
"0.8144138",
"0.81410587",
"0.8132492",
"0.8093973",
"0.80920255",
"0.80920255",
"0.80920255",
"0.8085325",
"0.8085325",
"0.8076365",
"0.8076365",
"0.8065748",
"0.8042487",
"0.8042487",
"0.8042487",
"0.8042487",
"0.8042487",
"0.8042487",
"0.8042487",
... | 0.0 | -1 |
Generates a unique id which will be used by paynow to refer to the payment initiated | def generate_transaction_id():
return str(int(time.time() * 1000)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _generate_id(self, context):\n tmp = datetime.datetime.now()\n tmp = tmp.strftime('%Y%m%d%H%M%S%f')\n tmp += context.peer()\n m = hashlib.md5()\n m.update(tmp.encode('utf-8'))\n return str(m.hexdigest())",
"def _generate_order_id():\n current_milli_time = str(... | [
"0.75733525",
"0.7475758",
"0.74029607",
"0.7379154",
"0.7355747",
"0.7351507",
"0.7347127",
"0.73232245",
"0.7290395",
"0.72684765",
"0.7227526",
"0.7220504",
"0.7218613",
"0.7189539",
"0.71791047",
"0.71791047",
"0.717642",
"0.71746486",
"0.71354276",
"0.71192765",
"0.71178... | 0.79250395 | 0 |
This the point where Paynow returns user to our site | def paynow_return(request, payment_id):
# Get payment object
payment = get_object_or_404(PaynowPayment, reference=payment_id)
# Init Paynow oject. The urls can now be blank
paynow = Paynow(settings.PAYNOW_INTEGRATION_ID, settings.PAYNOW_INTEGRATION_KEY, '', '')
# Check the status of the payme... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self):\n self.response.headers.add_header(\"Set-Cookie\", \"user_id=; Path=/\")\n self.redirect(\"/signup\")",
"def awaiting_payment(self):",
"def post(self):\n cont = self.request_string('continue', default=\"/\")\n self.redirect(users.create_login_url(cont))",
"def payRe... | [
"0.65489256",
"0.6326221",
"0.6302619",
"0.61190206",
"0.6105587",
"0.6082659",
"0.6058248",
"0.60442585",
"0.60005426",
"0.5996423",
"0.59853405",
"0.5955397",
"0.594845",
"0.59100366",
"0.58981246",
"0.5893184",
"0.5892947",
"0.58726484",
"0.5856111",
"0.5855935",
"0.585531... | 0.60124165 | 8 |
This the point which Paynow polls our site with a payment status. I find it best to check with the Paynow Server. I also do the check when a payer is returned to the site when user is returned to site | def paynow_update(request, payment_reference):
# Get saved paymend details
payment = get_object_or_404(PaynowPayment, reference=payment_reference)
# Init paynow object. The URLS can be blank
paynow = Paynow(settings.PAYNOW_INTEGRATION_ID, settings.PAYNOW_INTEGRATION_KEY, '', '')
# Check the s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_payment_status():\n\ttry:\n\t\torders = []\n\t\terror_log = {}\n\t\tfields = [\"name\", \"sales_tokens\"]\n\t\tfilters = {\n\t\t\t\"payment_status\": (\"in\", [\"Pending\", \"\", None]),\n\t\t\t\"docstatus\": (\"!=\", 2),\n\t\t\t\"mode_of_order\": \"Web\"\n\t\t}\n\t\tdue_orders = frappe.get_list(\"Sales ... | [
"0.7122953",
"0.7110178",
"0.65054214",
"0.639817",
"0.61742175",
"0.61226845",
"0.6104691",
"0.5995269",
"0.5959673",
"0.5959388",
"0.5890821",
"0.57182485",
"0.5644974",
"0.5628669",
"0.5604625",
"0.5577589",
"0.55546874",
"0.55534333",
"0.55522",
"0.5548011",
"0.5545392",
... | 0.6033519 | 7 |
Creates a new database session for a test. | def session(project, engine_sessionmaker, connection):
_, Session = engine_sessionmaker
try:
session = Session(bind=connection)
yield session
finally:
session.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _initTestingDB(): \n from sqlalchemy import create_engine\n engine = create_engine('sqlite://')\n from .models import (\n Base,\n TodoUser,\n )\n DBSession.configure(bind=engine)\n Base.metadata.create_all(engine)\n \n return DBSession",
"def create_test_db(self, *a... | [
"0.7618117",
"0.73792046",
"0.7159167",
"0.71482813",
"0.7045171",
"0.7042163",
"0.69432914",
"0.690918",
"0.6870981",
"0.6835914",
"0.6805257",
"0.6765318",
"0.6759865",
"0.673872",
"0.67327875",
"0.6709266",
"0.67053777",
"0.66906506",
"0.66815907",
"0.6679495",
"0.66528684... | 0.0 | -1 |
Reflect the elements of a numpy array along a specified axis about the first element. | def reflect(arr,axis=0,sign=1):
refl_idx = axis * [slice(None)] + [slice(None,0,-1), Ellipsis]
return np.concatenate((arr[tuple(refl_idx)],arr), axis=axis) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reflect_array(x, axis=1, kind='even'):\n if axis == 0:\n x_sym = np.flipud(x)\n elif axis == 1:\n x_sym = np.fliplr(x)\n else:\n raise NotImplementedError\n\n if kind == 'even':\n fact = 1.0\n elif kind == 'odd':\n fact = -1.0\n else:\n raise NotImple... | [
"0.67617947",
"0.6650867",
"0.61850905",
"0.6083956",
"0.5720959",
"0.57025504",
"0.5559801",
"0.5524613",
"0.55142355",
"0.54787475",
"0.5478125",
"0.5472565",
"0.54558724",
"0.5451142",
"0.53963137",
"0.53875583",
"0.5342568",
"0.5339039",
"0.5313937",
"0.53026325",
"0.5300... | 0.69821197 | 0 |
Return some points from a 2d lattice (with the origin first). | def make_lattice(min,max,lattice_vectors):
xs = np.roll(np.arange(min[0],max[0]),max[0])
ys = np.roll(np.arange(min[1],max[1]),max[1])
lattice = np.dstack(np.meshgrid(xs,ys)).reshape(-1,2)
lattice = np.matmul(lattice,lattice_vectors)
return lattice | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getLatticePoints():\n latticePoints = []\n\n for y in arange(yMin, yMax + yStep, yStep):\n for x in arange(xMin, xMax + xStep, xStep):\n latticePoints.append(LatticePoint(x, y))\n\n \n return latticePoints",
"def get_lattice_points(self) -> List[np.ndarray]:\n lattice_poi... | [
"0.72631",
"0.66125095",
"0.65590817",
"0.64682907",
"0.6441065",
"0.6329514",
"0.6315307",
"0.6234959",
"0.61652595",
"0.6115704",
"0.61074376",
"0.6102117",
"0.6076739",
"0.6037446",
"0.60364854",
"0.60296583",
"0.6005677",
"0.6000581",
"0.5999192",
"0.5998226",
"0.5966211"... | 0.0 | -1 |
Returns a list of flows with randomly selected sources and destinations that will saturate the network (i.e. a flow will be admitted provided that it would not cause the utilization of any link in the network to exceed 1. Flows are equally split across the K shortest paths connecting the source node to the destination ... | def compute_path_hopping_flow_allocations(target_graph, K=3):
flow_allocation_seed_number = 0xCAFE_BABE
np.random.seed(flow_allocation_seed_number)
# id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)
link_utilization = {(u, v): 0.0 for u, v in target_graph.edges}
node_c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_equal_flow_allocations(target_graph, K=3):\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n flow_allocation_seed_number = 0xDEAD_BEEF\n np.random.seed(flow_allocation_seed_number)\n flows = []\n for node in target_graph.nodes:\n possible_destination_nodes ... | [
"0.6073624",
"0.5772932",
"0.56998974",
"0.5527996",
"0.54848486",
"0.5443951",
"0.5443951",
"0.53789777",
"0.53648436",
"0.53508836",
"0.5280728",
"0.5269755",
"0.5099018",
"0.50866324",
"0.50755084",
"0.50711346",
"0.50711346",
"0.50291127",
"0.5007661",
"0.4996117",
"0.496... | 0.62126094 | 0 |
Returns a list of flows with randomly selected sources and destinations that will saturate the network (i.e. a flow will be addmitted provided that it will not cause the utilization of any link in the network to exceed 1. Flows are split across the K least utilized paths connecting the source node to the destination no... | def compute_greedy_flow_allocations( target_graph
, flow_selection_fn
, seed_number=DEFAULT_SEED_NUMBER):
flow_allocation_seed_number = seed_number
np.random.seed(flow_allocation_seed_number)
link_utilization = {tuple(sorted(link_tup... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_path_hopping_flow_allocations(target_graph, K=3):\n flow_allocation_seed_number = 0xCAFE_BABE\n np.random.seed(flow_allocation_seed_number)\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n link_utilization = {(u, v): 0.0 for u, v in target_graph.edges}\n... | [
"0.6332378",
"0.60935616",
"0.5811239",
"0.560641",
"0.5514502",
"0.5492238",
"0.5380612",
"0.5344111",
"0.5344111",
"0.53399456",
"0.5291331",
"0.5245833",
"0.52410334",
"0.5200011",
"0.51825786",
"0.51523155",
"0.51386243",
"0.51315624",
"0.5101362",
"0.5068613",
"0.5018153... | 0.622782 | 1 |
Returns a set of flows st. there will be a single flow sourced from each node in the network with a destination randomly chosen from the set V / {s} where V is the set of nodes in the graph and s is the source node of the flow. Flows are equally distributed over the three shortest paths connecting the source node to th... | def compute_equal_flow_allocations(target_graph, K=3):
# id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)
flow_allocation_seed_number = 0xDEAD_BEEF
np.random.seed(flow_allocation_seed_number)
flows = []
for node in target_graph.nodes:
possible_destination_nodes = set(targe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_paths_for_flow(F, s, f):\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links",
"def get_paths_for_flow(F, s, f):\n links = [((u, v), split_ratio) \n ... | [
"0.5869763",
"0.5869763",
"0.5623528",
"0.558636",
"0.55374354",
"0.5450709",
"0.54248506",
"0.54232466",
"0.53542936",
"0.532742",
"0.53266317",
"0.5317662",
"0.53176224",
"0.53126985",
"0.5301199",
"0.528309",
"0.5279385",
"0.52754855",
"0.5249356",
"0.52429557",
"0.5217097... | 0.5799766 | 2 |
Returns a set of flows st. there will be a single flow sourced from each node in the network with a destination randomly chosen from the set V / {s} where V is the set of nodes in the graph and s is the source node of the flow. Flows are split over the three shortest paths connecting the sender to the receiver in such ... | def compute_unequal_flow_allocations(target_graph, K=3):
# id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)
flow_allocation_seed_number = 0xDEAD_BEEF
np.random.seed(flow_allocation_seed_number)
flows = []
link_utilization = {}
for node in target_graph.nodes:
possible_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_paths_for_flow(F, s, f):\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links",
"def get_paths_for_flow(F, s, f):\n links = [((u, v), split_ratio) \n ... | [
"0.6088071",
"0.6088071",
"0.58521134",
"0.56622416",
"0.5531953",
"0.5518096",
"0.54397494",
"0.54385334",
"0.54131764",
"0.5411593",
"0.53891915",
"0.5348688",
"0.53438646",
"0.5327883",
"0.52937067",
"0.5290496",
"0.5274863",
"0.5273465",
"0.5230514",
"0.5225777",
"0.52235... | 0.0 | -1 |
r""" RETURNS A set of paths, P. \forall p_i \in P, p_i begins at s and ends at t. The set also includes the proportion of flow f that should transit each path p_i \in P | def traverse_graph(F, f, s, t, u, sr):
def get_paths_for_flow(F, s, f):
"""
RETURNS
A set of outgoing links and corresponding splitting ratios for flow f
at node s
"""
links = [((u, v), split_ratio)
for (flow_id, u, v), split_ratio in F.items(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_paths_for_flow(F, s, f):\n links = [((u, v), split_ratio) \n for (flow_id, u, v), split_ratio in F.items() \n if flow_id == f and u == s and split_ratio > 0.001]\n return links",
"def get_paths_for_flow(F, s, f):\n links = [((u, v), split_ratio) \n ... | [
"0.6825437",
"0.6825437",
"0.6509935",
"0.5756425",
"0.5675671",
"0.5626487",
"0.55647385",
"0.5557139",
"0.554731",
"0.55453545",
"0.5439347",
"0.5434702",
"0.5434155",
"0.5415356",
"0.54112595",
"0.5397447",
"0.5393359",
"0.53482777",
"0.53389424",
"0.5324333",
"0.5324295",... | 0.6100076 | 3 |
RETURNS A set of outgoing links and corresponding splitting ratios for flow f at node s | def get_paths_for_flow(F, s, f):
links = [((u, v), split_ratio)
for (flow_id, u, v), split_ratio in F.items()
if flow_id == f and u == s and split_ratio > 0.001]
return links | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def traverse_graph(F, f, s, t, u, sr):\n def get_paths_for_flow(F, s, f):\n \"\"\"\n RETURNS\n A set of outgoing links and corresponding splitting ratios for flow f\n at node s\n \"\"\"\n links = [((u, v), split_ratio) \n for (flow_id, u, v), spli... | [
"0.69459766",
"0.5595106",
"0.5534561",
"0.5483686",
"0.54691195",
"0.5467508",
"0.53494895",
"0.53470665",
"0.53366846",
"0.53234804",
"0.5310389",
"0.52716064",
"0.52382374",
"0.5235263",
"0.52303815",
"0.5227401",
"0.52202076",
"0.5218126",
"0.5190948",
"0.51826143",
"0.51... | 0.7221145 | 1 |
RETURNS A set of outgoing links and corresponding splitting ratios for flow f at node s | def get_paths_for_flow(F, s, f):
links = [((u, v), split_ratio)
for (flow_id, u, v), split_ratio in F.items()
if flow_id == f and u == s and split_ratio > 0.001]
return links | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def traverse_graph(F, f, s, t, u, sr):\n def get_paths_for_flow(F, s, f):\n \"\"\"\n RETURNS\n A set of outgoing links and corresponding splitting ratios for flow f\n at node s\n \"\"\"\n links = [((u, v), split_ratio) \n for (flow_id, u, v), spli... | [
"0.6946733",
"0.5595293",
"0.55341357",
"0.5483804",
"0.54689676",
"0.546619",
"0.53488106",
"0.5347624",
"0.53359586",
"0.5324602",
"0.531136",
"0.527324",
"0.52406126",
"0.52348506",
"0.52295214",
"0.5226473",
"0.5220885",
"0.52176976",
"0.5189963",
"0.5180724",
"0.5178925"... | 0.7221145 | 0 |
View function for home page of site. | def summary(request):
# Generate counts of some of the main objects
num_courses = models.Course.objects.all().count()
num_quizzes = models.Quiz.objects.all().count()
num_questions = models.Question.objects.count()
num_students = models.User.objects.count()
num_visits = request.session.get('num_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def home(request):\n\treturn render(request, \"compta/home.html\")",
"def home_page(request):\r\n return render(request, 'ez_main/home_page.html')",
"def home(request):\r\n return render(request, 'home.html')",
"def homepage(request):\n\treturn render(request, 'core/homepage.html')",
"def homepage(req... | [
"0.8493426",
"0.84268916",
"0.83415145",
"0.83306193",
"0.82976943",
"0.8295291",
"0.8276345",
"0.82545686",
"0.82155704",
"0.8132563",
"0.81246215",
"0.81224865",
"0.8121264",
"0.81049734",
"0.8098485",
"0.80935514",
"0.80935514",
"0.80935514",
"0.80935514",
"0.80935514",
"0... | 0.0 | -1 |
Creates an address for a purchase. | def __init__(self, street="", street2="", city="", state="", zip_code=""):
self.street = street
self.street2 = street2
self.city = city
self.state = state
self.zip_code = zip_code | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generateNewAddress(self, currency):\n pass",
"def create_address(self, address: str) -> Optional[Address]:\n raise NotImplemented",
"def test_create_shipping_address(self):\n self.cim.create_shipping_address(\n customer_profile_id=100,\n ship_phone=u'415-415-4154'... | [
"0.73644215",
"0.7143773",
"0.7031508",
"0.6538616",
"0.64551836",
"0.64361376",
"0.64270854",
"0.6425408",
"0.6418397",
"0.63918406",
"0.6356949",
"0.62770784",
"0.6219692",
"0.62043613",
"0.6161881",
"0.6076241",
"0.6072444",
"0.6055833",
"0.6051252",
"0.60130686",
"0.59843... | 0.0 | -1 |
Given a vehicle and its current visiting customer, return the next visiting customer. Here we use the Timeoriented NearestNeighborhood Heuristic proposed by Solomon(1987). | def time_nn(self, on_way_time, curr_cust, remain_list, used_resource, rout_len, vehicle_type):
if vehicle_type == 2:
veh_cap = small_veh
elif vehicle_type == 3:
veh_cap = medium_veh
else:
veh_cap = large_veh
real_wait_time = 0 # the final wait ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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 in... | [
"0.6084116",
"0.5874696",
"0.5782421",
"0.57132584",
"0.5656202",
"0.56430805",
"0.5636324",
"0.5563873",
"0.5542704",
"0.5528435",
"0.5520394",
"0.5506145",
"0.5500587",
"0.54915744",
"0.54864365",
"0.5473194",
"0.54112583",
"0.53902376",
"0.53827214",
"0.53707117",
"0.53412... | 0.0 | -1 |
Generate an initial solution based on the Timeoriented Nearestneighbor heuristic proposed by Solomon. | def greedy_initial(self):
sol = [] # [[0;2;5;0;4;6;0],[],...]
sol_veh_type = [] # corresponding vehicle type for the solution
route_way_time = []
to_vist = [i+1 for i in range(store_num - 1)] # [1,5,8,...]
itr = 0
while len(to_vist) > 0 and itr < 500:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve(self):\n # Use a trivial tour (1-2-3-...-N-1) to set the global upper bound.\n tour = list(range(self._N))\n upper_bound = sum([self._G[i][(i + 1) % self._N] for i in range(self._N)])\n trace = []\n\n # Start from a configuration with a single vertex.\n frontier = [BranchAndBoundConfigu... | [
"0.6477208",
"0.63721377",
"0.63295656",
"0.6317618",
"0.62916344",
"0.6283113",
"0.62769455",
"0.627362",
"0.6254762",
"0.62242985",
"0.6224087",
"0.61772007",
"0.6172025",
"0.61346906",
"0.61340076",
"0.611956",
"0.6112025",
"0.6105103",
"0.6101848",
"0.60936993",
"0.607927... | 0.63413787 | 2 |
Given the solution saved in list, calculate the total cost of the solution. Write the solution to local in the required format. | def print_result(self, solution, vehicle_type, if_write):
result = [['Vehicle_ID', 'Vehicle_type', 'Route', 'Leave_Time', 'Back_Time', 'Work_Time', 'Distance',
'Load_Volume', 'Wait_Time', 'Fixed_Cost', 'Travel_Cost', 'Total_Cost']]
total_dist = 0
total_cost = 0
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_and_save_solution(data, manager, routing, assignment):\n total_distance = 0\n total_load = 0\n routes = []\n for vehicle_id in range(data['num_vehicles']):\n route = []\n index = routing.Start(vehicle_id)\n plan_output = 'Route for vehicle {}:\\n'.format(vehicle_id)\n ... | [
"0.60077643",
"0.59991765",
"0.5897307",
"0.5896258",
"0.5895152",
"0.5890144",
"0.5856607",
"0.58172816",
"0.5780239",
"0.5713375",
"0.5707637",
"0.57038105",
"0.57038105",
"0.5679921",
"0.5667275",
"0.5651229",
"0.5595291",
"0.5590735",
"0.55840975",
"0.5565297",
"0.5565179... | 0.5381247 | 35 |
Given the solution saved in list, calculate the total cost of the solution. Write the solution to local in the required format. | def print_route_detail(self, solution, vehicle_type, if_write):
result = [[
'线路编号',
'门店编码',
'门店名称',
'门店地址',
'经度',
'纬度',
'车型',
'额定体积/m3',
'额定重量/t',
'到达时间',
'离开时间',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_and_save_solution(data, manager, routing, assignment):\n total_distance = 0\n total_load = 0\n routes = []\n for vehicle_id in range(data['num_vehicles']):\n route = []\n index = routing.Start(vehicle_id)\n plan_output = 'Route for vehicle {}:\\n'.format(vehicle_id)\n ... | [
"0.60075754",
"0.599813",
"0.5897581",
"0.58958864",
"0.58943343",
"0.58902836",
"0.5857024",
"0.5817814",
"0.5779555",
"0.5712807",
"0.57073516",
"0.57030547",
"0.57030547",
"0.56806123",
"0.5668559",
"0.56510866",
"0.5595581",
"0.55908483",
"0.5583591",
"0.5566087",
"0.5564... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.