0:\n split_folders = [folder for folder in output_list\n if folder.startswith(output_folder_prefix)]\n if len(split_folders) > 0:\n last_output_folder = split_folders[-1]\n last_output_index = int(last_output_folder.split('_')[-1])\n else:\n last_output_index = -1\n else:\n last_output_index = -1\n output_depth_dir = outputs_dir + '/{}_{:03d}'.format(\n output_folder_prefix, last_output_index + 1)\n\n if save_output:\n if not os.path.exists(output_depth_dir):\n os.makedirs(output_depth_dir)\n else:\n raise FileExistsError('Already exists!')\n print('Output dir:', output_depth_dir)\n\n # Get images in sorted order\n # images_to_use = sorted(glob.glob(input_depth_dir + '/*'))\n\n # Rolling average array of times for time estimation\n avg_time_arr_length = 10\n last_fill_times = np.repeat([1.0], avg_time_arr_length)\n last_total_times = np.repeat([1.0], avg_time_arr_length)\n\n images_to_use = []\n saved_path = []\n folder_path =\"./data_depth_selection/depth_selection/test_depth_completion_anonymous/velodyne_raw\"\n for img_name in os.listdir(folder_path):\n img_path = os.path.join(folder_path,img_name)\n saved_path_name = os.path.join(\"./output\", img_name)\n saved_path.append(saved_path_name)\n images_to_use.append(img_path)\n # if \"output\" not in os.listdir(\"Kitti/depth/\"):\n # os.mkdir(\"Kitti/depth/output\")\n # os.mkdir(\"output\")\n # for folder in os.listdir(folder_path):\n # # os.mkdir(\"./output/\"+folder)\n # # os.mkdir(\"./output/\"+folder+\"/2011_09_26/\")\n # # os.mkdir(\"./output/\"+folder+\"/2011_09_26/\"+folder+\"/\")\n\n # inside_folder_path = folder_path + \"/\" + folder+\"/2011_09_26/\"+folder+\"/\"\n # for img_folder in os.listdir(inside_folder_path):\n # print((\"/output/\"+folder+\"/2011_09_26/\"+folder+\"/\"+img_folder))\n # # os.mkdir(\"./output/\"+folder+\"/2011_09_26/\"+folder+\"/\"+img_folder)\n # print(inside_folder_path + img_folder)\n # # os.mkdir(\"Kitti/depth/output/\"+folder+\"/proj_depth/groundtruth/\"+img_folder)\n # img_path = inside_folder_path + img_folder+\"/data\"\n # try:\n # print(\"............................................................\",\"./depth_images/train/\" + folder + \"/proj_depth/groundtruth/\"+img_folder)\n # depth_image_folder = os.listdir(\"./depth_images/train/\" + folder + \"/proj_depth/groundtruth/\"+img_folder)\n # # print(depth_image_folder)\n # for img in os.listdir(img_path):\n # # image_path = +\"/\"+img\n # # print(img)\n # if img in depth_image_folder:\n # # print(\"aaya\")\n # depth_image_path = \"./depth_images/train/\" + folder + \"/proj_depth/groundtruth/\"+img_folder+\"/\"+img\n # images_to_use.append(depth_image_path)\n # saved_path.append(\"./output/\"+folder+\"/2011_09_26/\"+folder+\"/\"+img_folder+\"/\"+img)\n # except Exception:\n # print(\"folder nahi hai\")\n \n images_to_use = np.array(images_to_use)\n \n num_images = len(images_to_use)\n\n print(len(images_to_use))\n\n\n for i in range(num_images):\n\n depth_image_path = images_to_use[i]\n\n # Calculate average time with last n fill times\n avg_fill_time = np.mean(last_fill_times)\n avg_total_time = np.mean(last_total_times)\n\n # Show progress\n sys.stdout.write('\\rProcessing {} / {}, '\n 'Avg Fill Time: {:.5f}s, '\n 'Avg Total Time: {:.5f}s, '\n 'Est Time Remaining: {:.3f}s'.format(\n i, num_images - 1, avg_fill_time, avg_total_time,\n avg_total_time * (num_images - i)))\n sys.stdout.flush()\n\n # Start timing\n start_total_time = time.time()\n print(depth_image_path)\n # Load depth projections from uint16 image\n depth_image = cv2.imread(depth_image_path, cv2.IMREAD_ANYDEPTH)\n projected_depths = np.float32(depth_image / 256.0)\n\n # Fill in\n start_fill_time = time.time()\n if fill_type == 'fast':\n final_depths = depth_map_utils.fill_in_fast(\n projected_depths, extrapolate=extrapolate, blur_type=blur_type)\n elif fill_type == 'multiscale':\n final_depths, process_dict = depth_map_utils.fill_in_multiscale(\n projected_depths, extrapolate=extrapolate, blur_type=blur_type,\n show_process=show_process)\n else:\n raise ValueError('Invalid fill_type {}'.format(fill_type))\n end_fill_time = time.time()\n\n # Display images from process_dict\n if fill_type == 'multiscale' and show_process:\n img_size = (570, 165)\n\n x_start = 80\n y_start = 50\n x_offset = img_size[0]\n y_offset = img_size[1]\n x_padding = 0\n y_padding = 28\n\n img_x = x_start\n img_y = y_start\n max_x = 1900\n\n row_idx = 0\n for key, value in process_dict.items():\n\n image_jet = cv2.applyColorMap(\n np.uint8(value / np.amax(value) * 255),\n cv2.COLORMAP_JET)\n vis_utils.cv2_show_image(\n key, image_jet,\n img_size, (img_x, img_y))\n\n img_x += x_offset + x_padding\n if (img_x + x_offset + x_padding) > max_x:\n img_x = x_start\n row_idx += 1\n img_y = y_start + row_idx * (y_offset + y_padding)\n\n # Save process images\n cv2.imwrite('process/' + key + '.png', image_jet)\n\n cv2.waitKey()\n\n # Save depth images to disk\n if save_depth_maps:\n depth_image_file_name = depth_image_path.split(\"/\")\n # print(depth_image_file_name)\n file_path = \"\"\n print(len(depth_image_file_name))\n # for i in range(8):\n # if(i == 2):\n # file_path = os.path.join(file_path, \"output\")\n # else:\n # file_path = os.path.join(file_path, depth_image_file_name[i])\n # cv2.imwrite(file_path, depth_image)\n # print(\"check.............................\",saved_path[i])\n # with open(saved_path[i],'r') as f:\n # print(\"badhiya\") \n depth_image = (final_depths * 256)\n # plt.imsave(saved_path[i],depth_image)\n # cv2.imwrite(saved_path[i], depth_image)\n # print(saved_path[i])\n # cv2.imwrite(\"/media/pankaj/Elements/ip_basic\"+saved_path[i], depth_image)\n \n try:\n with open(saved_path[i], 'wb') as f:\n depth_image = (final_depths * 256).astype(np.uint16)\n\n writer = png.Writer(width=depth_image.shape[1],\n height=depth_image.shape[0],\n bitdepth=16,\n greyscale=True)\n writer.write(f, depth_image)\n except Exception:\n print(\"nikl.............\")\n\n end_total_time = time.time()\n\n # Update fill times\n last_fill_times = np.roll(last_fill_times, -1)\n last_fill_times[-1] = end_fill_time - start_fill_time\n\n # Update total times\n last_total_times = np.roll(last_total_times, -1)\n last_total_times[-1] = end_total_time - start_total_time","def test_launch_config_personality_with_max_path_size(self):\n long_path = 'z' * (self.personality_maxlength + 1)\n personality = [{'path': '/root/{0}.txt'.format(long_path),\n 'contents': base64.b64encode('tests')}]\n self._assert_create_group(personality)","def set_depth(self, depth):\n self._depth = depth\n if self._scaled_image_coordinates is None:\n self._initialise()\n else:\n self._update_depth()","def update_pkg(dir_layout:dict, source_path:Path, dest_path:Path, dry_run=True, exclude=[]):\n for folder_name, data in dir_layout.items():\n print(f\"DIR: {folder_name}\")\n print(f\"SRC: {source_path}\")\n print(f\"DST: {dest_path}\")\n for item in iterate_files(data):\n match = function_name_pattern.search(item)\n if match:\n # Use recursive Unix-like glob matching to find exact paths \n # files in source directory using matched file name.\n function_name = match.group(1)\n else:\n function_name = os.path.splitext(item)[0]\n\n sources = list(source_path.glob(\"**/\"+function_name+\".?\"))\n\n if sources: # Check that a matching file was found.\n if len(sources)>1:\n # Possibly picked up .p files, extract only '.m' files.\n sources = [s for s in sources if s.suffix == \".m\"]\n for excl_pattern in exclude:\n print(f\">>> Excluding '{excl_pattern}'\")\n sources = [s for s in sources if not fnmatch.fnmatch(s, excl_pattern)]\n assert len(sources) == 1, sources\n source = sources[0]\n # concatenate destination path\n destination = dest_path/folder_name/os.path.split(source)[1]\n print(f\" source: {source}\")\n print(f\" dest: {destination}\\n\")\n\n if not dry_run:\n os.makedirs(os.path.dirname(destination),exist_ok=True)\n shutil.copy(source,destination)\n else:\n print(f\"FILE NOT FOUND: {function_name}\")\n\n if isinstance(data, dict) and is_dir(data):\n update_pkg(data,source_path,dest_path/folder_name, dry,exclude=exclude)","def __init__(self, filenameOrPath, dirPath=None, compresslevel=9, logger=None, verbose=True, indent=None, closeAtEachAppend=True):\n\t\tself.closeAtEachAppend = closeAtEachAppend\n\t\tself.writeFile = None\n\t\tself.indent = indent\n\t\tself.logger = logger\n\t\tself.verbose = verbose\n\t\tself.compresslevel = compresslevel\n\t\tself.alreadyWarnedAboutMoSize = False\n\t\tif self.compresslevel is None:\n\t\t\tself.compresslevel = 0\n\t\tif filenameOrPath is None:\n\t\t\traise Exception(\"filenameOrPath param is None\")\n\t\tif \"/\" in filenameOrPath and dirPath is not None:\n\t\t\traise Exception(\"Don't use a path in bot fileNameOrPath and dirPath\")\n\t\tif \"/\" in filenameOrPath and not (filenameOrPath[-4:] == \".bz2\" or filenameOrPath[-7:] == \".ndjson\"):\n\t\t\traise Exception(\"Please use bz2 or ndjson extensions\")\n\t\tif \"/\" in filenameOrPath and not (filenameOrPath.startswith(\"/\") or filenameOrPath.startswith(\"~\")):\n\t\t\traise Exception(\"Please give an absolute path\")\n\t\tif \"/\" in filenameOrPath:\n\t\t\t(dirPath, filename, ext, _) = decomposePath2(filenameOrPath)\n\t\telse:\n\t\t\tif dirPath is None:\n\t\t\t\tdirPath = tmpDir()\n\t\t\tif len(filenameOrPath) > 4 and filenameOrPath[-4:] == \".bz2\":\n\t\t\t\tfilename = filenameOrPath[:-4]\n\t\t\t\text = \"bz2\"\n\t\t\telif len(filenameOrPath) > 7 and filenameOrPath[-7:] == \".ndjson\":\n\t\t\t\tfilename = filenameOrPath[:-7]\n\t\t\t\text = \"ndjson\"\n\t\t\telse:\n\t\t\t\tfilename = filenameOrPath\n\t\t\t\tif self.compresslevel > 0:\n\t\t\t\t\text = \"bz2\"\n\t\t\t\telse:\n\t\t\t\t\text = \"ndjson\"\n\t\tself.path = dirPath + \"/\" + filename + \".\" + ext\n\t\tif ext != \"bz2\":\n\t\t\tif self.compresslevel > 0:\n\t\t\t\tlogWarning(\"We will not compress \" + self.path, self)\n\t\t\tself.compresslevel = 0\n\t\tself.estimatedSizeRefreshCount = 0\n\t\tself.previousMoSize = None","def __write_files(self, kind:str, prog:progress=None):\n\t\tself.written_sectors = 0\n\t\tself.write_elapsed = 0.0\t\t\t\t\n\t\tself.filematrix.reset(kind == 'dynamic')\t\n\t\tself.__ipc_send_progress(prog, 0)\n\n\t\twhile not self.filematrix.done():\t\t\n\t\t\tif (self.__check_terminated()):\n\t\t\t\treturn;\n\n\t\t\tfp = self.filematrix.next()\n\n\t\t\tif (kind == 'all'):\n\t\t\t\tif (self.prev_mode != self.filematrix.current.mode):\n\t\t\t\t\tif (self.filematrix.current.mode == fsmode.dynamic):\n\t\t\t\t\t\tself.__ipc_send_status(\"Write all files - DYNAMIC\")\t\n\t\t\t\t\telse:\n\t\t\t\t\t\tself.__ipc_send_status(\"Write all files - STATIC\")\t\n\n\t\t\t\t\tself.prev_mode = self.filematrix.current.mode \t\t\t\t\t\t\n\n\t\t\t####logging.info('write path:' + fp.path + ', size: ' + str(fp.size) + ', seed: ' + str(fp.rand_seed))\n\n\t\t\tif not os.path.exists(fp.folder):\n\t\t\t\ttry:\n\t\t\t\t\tos.mkdir(fp.folder)\t\t\t\t\t\t\t\n\t\t\t\texcept:\n\t\t\t\t\t raise_error(FileNotFoundError, myerror.dir_error, \"create directory fail\")\n\t\t\telif not os.access(fp.folder, os.F_OK):\n\t\t\t\tos.mkdir(fp.folder)\t\n\t\t\t\t\n\t\t\ttime.sleep(0.001)\t\t\t\t\n\t\t\t\t\n\t\t\t#try:\t\t\t\t\t\t\t\n\t\t\t#\twith iolib.fopen(fp.path, 'wb') as f:\n\t\t\t#\t\tpass\t\t\t\t\n\t\t\t#except (PermissionError) as err:\t\t\t\n\t\t\t#\traise_error(PermissionError, myerror.dir_error, str(err))\n\t\t\t\t\t\t\t\t\t\t\t \n\t\t\twith iolib.fopen(fp.path, 'wb') as f:\n\t\t\t\tremain = fp.size\n\t\t\t\tfile_time = 0.0\n\t\t\t\tstart = 0.0\n\t\t\t\telapsed = 0.0\n\t\t\t\t\n\t\t\t\twhile (remain != 0):\n\t\t\t\t\tif (self.__check_terminated()):\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\tchunk_sectors = min(remain, self.max_buff_size)\t\t\t\t\t\t\t\t\t\n\t\t\t\t\tbuff = self.__random_chunk_pattern(chunk_sectors, fp.rand_seed)\t\t\t\t\t\n\t\t\t\t\t#buff = self.__next_chunk_pattern(chunk_sectors)\t\n\t\t\t\t\twritten, elapsed = iolib.write(buff, 512, chunk_sectors, f)\n\t\t\t\t\tfile_time += elapsed\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t \n\t\t\t\t\tself.written_sectors += int(written)\n\t\t\t\t\tremain = remain - chunk_sectors\n\t\t\t\t\n\t\t\t\tself.write_elapsed += file_time\n\t\t\n\t\t\t\ttime.sleep(0.001)\n\t\t\t\n\t\t\tself.__ipc_send_progress(prog, self.filematrix.get_progress())","def SetToolPacking(self, packing):\r\n\r\n self._tool_packing = packing","def mark_best(run_directory: Union[str, Path]) -> None:\n run_directory = Path(run_directory).resolve()\n mark_best_explicit(run_directory, run_directory.parent)","def pkgOverride(self, keyList = None, pkgFlag = True, titleFlag = None):\n\n # Quick and dirty check for list type.\n if type(keyList) is not list:\n keyList = [keyList]\n\n\n print('\\n***Packaging override...')\n\n # Manual set for pkg override of selected jobs\n for key in keyList:\n print(f\"\\n***Job {key}: {self.nbDetails[key]['title']}\")\n print(self.nbDetails[key]['jobInfo'])\n\n # Check and change title if desired\n if titleFlag is None:\n # Manual title overrides, ugh.\n titleFlag = input(\"Change title? (y/n) \")\n if titleFlag == 'y': titleFlag = True\n else: titleFlag = False\n\n\n if titleFlag:\n test = input(f\"Suggested title: {self.nbDetails[key]['jobInfo'][3].strip().rsplit(',',1)[0]} (y/n)\")\n\n if test == 'y':\n # For old-style jobs, use longer version of title\n # self.nbDetails[key]['title'] = self.nbDetails[key]['jobInfo'][3].strip().rsplit(',',1)[0]\n # Version + energy range.\n self.nbDetails[key]['title'] = self.nbDetails[key]['jobInfo'][3].strip().rsplit(',',1)[0] + f\", {self.nbDetails[key]['E'][0]} - {self.nbDetails[key]['E'][2]} eV\"\n else:\n self.nbDetails[key]['title'] = input(\"New title? \")\n\n if pkgFlag:\n\n # Set for packaging\n self.nbDetails[key]['pkg'] = True\n self.nbDetails[key]['repo'] = 'Zenodo'\n print(\"Set pkg = True\")\n\n # Override arch check\n if 'archFileCheck' in self.nbDetails[key].keys():\n print(f\"Arch file check: {self.nbDetails[key]['archFileCheck']}\")\n print(f\"Arch files OK: {self.nbDetails[key]['archFilesOK']}\")\n print(\"Setting to True\")\n self.nbDetails[key]['archFileCheck'] = True\n self.nbDetails[key]['archFilesOK'] = True\n else:\n print(f\"Arch files not yet set and checked - run this again after updateUploads().\")\n\n\n # Reset eStructure\n # job.setESFiles(eSourceDir=job.hostDefn[job.host]['jobDir']/'electronic_structure', verbose=True)\n\n # job.nbDetails[5]['pkg'] = False\n # job.delRepoItem(4)\n # Rewrite JSON\n # Update remote\n self.writeNBdetailsJSON()","def __init__(self, output_dir, fstype, num_disks, num_dirs):\n super(PostMarkTest, self).__init__(fstype, num_disks)\n self.num_dirs = num_dirs\n self.output_dir = output_dir\n self.configurations = []","def increment_depth(self):\r\n self.depth = self.depth + 1","def get_max_depth(self):\n return self.MAX_DEPTH","def test_launch_config_personality_with_max_file_content_size(self):\n file_content = 'z' * (self.personality_max_file_size + 1)\n personality = [{'path': self.path,\n 'contents': base64.b64encode(file_content)}]\n self._assert_create_group(personality)","def algorithm(self, groupInstance = None, jobInstance = None,\n *args, **kwargs):\n # extract some global scheduling parameters\n self.jobNamePrefix = kwargs.get('jobNamePrefix', \"Repack\")\n self.maxSizeSingleLumi = kwargs['maxSizeSingleLumi']\n self.maxSizeMultiLumi = kwargs['maxSizeMultiLumi']\n self.maxInputEvents = kwargs['maxInputEvents']\n self.maxInputFiles = kwargs['maxInputFiles']\n self.maxLatency = kwargs['maxLatency']\n\n self.currentTime = time.time()\n\n self.createdGroup = False\n\n timePerEvent, sizePerEvent, memoryRequirement = \\\n self.getPerformanceParameters(kwargs.get('performance', {}))\n \n myThread = threading.currentThread()\n daoFactory = DAOFactory(package = \"T0.WMBS\",\n logger = logging,\n dbinterface = myThread.dbi)\n\n # keep for later\n self.insertSplitLumisDAO = daoFactory(classname = \"JobSplitting.InsertSplitLumis\")\n\n # data discovery\n getAvailableFilesDAO = daoFactory(classname = \"Subscriptions.GetAvailableRepackFiles\")\n availableFiles = getAvailableFilesDAO.execute(self.subscription[\"id\"])\n\n # nothing to do, stop immediately\n if len(availableFiles) == 0:\n return\n\n # data discovery for already used lumis\n getUsedLumisDAO = daoFactory(classname = \"Subscriptions.GetUsedLumis\")\n usedLumis = getUsedLumisDAO.execute(self.subscription[\"id\"], False)\n\n # empty lumis (as declared by StorageManager) are treated the\n # same way as used lumis, ie. we process around them\n getEmptyLumisDAO = daoFactory(classname = \"Subscriptions.GetLumiHolesForRepack\")\n usedLumis |= getEmptyLumisDAO.execute(self.subscription[\"id\"])\n\n # sort available files by lumi\n availableFileLumiDict = {}\n for result in availableFiles:\n lumi = result['lumi']\n if not lumi in availableFileLumiDict:\n availableFileLumiDict[lumi] = []\n availableFileLumiDict[lumi].append(result)\n\n # loop through lumis in order\n haveLumiHole = False\n filesByLumi = {}\n maxUsedLumi = max(usedLumis) if usedLumis else 0\n for lumi in range(1, 1+max(maxUsedLumi,max(availableFileLumiDict.keys()))):\n\n # lumi contains data => remember it for potential processing\n if lumi in availableFileLumiDict:\n\n filesByLumi[lumi] = availableFileLumiDict[lumi]\n\n # lumi is used and we have data => trigger processing\n elif lumi in usedLumis:\n\n if len(filesByLumi) > 0:\n\n if haveLumiHole:\n # if lumi hole check for maxLatency first\n if self.getDataAge(filesByLumi) > self.maxLatency:\n self.defineJobs(filesByLumi, True, memoryRequirement)\n filesByLumi = {}\n # if maxLatency not met ignore data for now\n else:\n filesByLumi = {}\n else:\n self.defineJobs(filesByLumi, True, memoryRequirement)\n filesByLumi = {}\n\n # if we had a lumi hole it is now not relevant anymore\n # the next data will have a used lumi in front of it\n haveLumiHole = False\n\n # lumi has no data and isn't used, ie. we have a lumi hole\n # also has an impact on how to handle later data\n else:\n\n if len(filesByLumi) > 0:\n\n # forceClose if maxLatency trigger is met\n if self.getDataAge(filesByLumi) > self.maxLatency:\n self.defineJobs(filesByLumi, True, memoryRequirement)\n filesByLumi = {}\n # follow the normal thresholds, but only if\n # there is no lumi hole in front of the data\n elif not haveLumiHole:\n self.defineJobs(filesByLumi, False, memoryRequirement)\n filesByLumi = {}\n # otherwise ignore the data for now\n else:\n filesByLumi = {}\n\n haveLumiHole = True\n\n # now handle whatever data is still left (at the high end of the lumi range)\n if haveLumiHole:\n if self.getDataAge(filesByLumi) > self.maxLatency:\n self.defineJobs(filesByLumi, True, memoryRequirement)\n else:\n fileset = self.subscription.getFileset()\n fileset.load()\n self.defineJobs(filesByLumi, not fileset.open, memoryRequirement)\n\n return","def get_directory_limits():\n pass","def getMaxFile(self, channel):\n maxSavePath, fileName = os.path.split(self.path)\n baseFileName = os.path.splitext(fileName)[0]\n maxSavePath = os.path.join(maxSavePath, 'max')\n maxFileName = 'max_' + baseFileName + '_ch' + str(channel) + '.tif'\n maxFilePath = os.path.join(maxSavePath, maxFileName)\n return maxFilePath","def max_depth(self) -> int:\n return pulumi.get(self, \"max_depth\")","def walkthrough(software_map):\n\n for i in software_map:\n\n if not i[\"is_file\"]:\n\n # for each directory: make a index.md\n dname = \"./docs/\" + i[\"name\"]\n index = \"./docs/\" + i[\"name\"] + \"/index.md\"\n print(index)\n os.mkdir(dname)\n\n with open(index, \"w+\") as f:\n\n children = i[\"children\"]\n\n # list files\n f.write(\"Files:\\n\\n\")\n for i in children:\n if i[\"is_file\"]:\n\n fname = i[\"name\"]\n fext = fname.split(\".\")\n if len(fext) == 2:\n fext = fext[1]\n else:\n fext = \"none\"\n # for each file, note name and extension\n f.write(fname + \" : \" + fext + \"\\n\")\n\n # list subdirectories\n f.write(\"\\nSubdirectories:\\n\\n\")\n for i in children:\n if not i[\"is_file\"]:\n\n dirname = i[\"name\"]\n\n # note the number of files and subdirs in it\n num_files, num_dirs = 0, 0\n for child in i[\"children\"]:\n if child[\"is_file\"]:\n num_files += 1\n elif not child[\"is_file\"]:\n num_dirs += 1\n\n # note down name and numbers for each dir\n f.write(dirname + \" : \" + str(num_files) + \" files, \" +\n str(num_dirs) + \" directories\\n\")\n\n # goto subdir\n if len(i[\"children\"]) > 0:\n walkthrough(i[\"children\"])","def depth(self, create, depth, **kwargs): # pylint: disable=unused-argument\r\n # pylint: disable=no-member\r\n if depth == 0:\r\n self.load_item.side_effect = lambda x: LeafModuleFactory(descriptor_cls=HtmlDescriptor)\r\n else:\r\n self.load_item.side_effect = lambda x: ContainerModuleFactory(descriptor_cls=VerticalDescriptor, depth=depth - 1)","def max_weight(self):\n raise NotImplementedError(\"subclasses need to override this method\")","def update_level(self):\n level = 1\n assigned_levels = set([])\n just_assigned = set([])\n for root in self.roots:\n for child in root.children:\n if child in just_assigned:\n continue\n child.level = level\n if len(child.children) == 0:\n continue\n just_assigned.add(child)\n assigned_levels = assigned_levels.union(just_assigned)\n\n level += 1\n leaves = [c for c in self.collectors if len(c.children) == 0]\n len_non_leaves = len(self.collectors) - len(leaves)\n self.update_level_for_non_leaves(\n level, assigned_levels, just_assigned, len_non_leaves\n )","def main():\n global MASK\n start_time = time()\n parser = initArgparse()\n args = parser.parse_args()\n dirtree = args.directorytree\n filetree = args.filetree\n meta = args.metadata\n newmeta = args.newmetadata\n sfv = args.sfv\n yes = args.yes\n MASK = args.exclude\n\n for i in args.DIRECTORY:\n if Path(i).exists() is True:\n basepath = Path(i)\n else:\n raise NotADirectoryError(f\"{i} does not exist\")\n default = False\n if dirtree == sfv == filetree == meta == newmeta is False:\n default = True\n if dirtree is True or default is True:\n dirtree_file = f\"{basepath.name}_directory_tree.txt\"\n checkFileExists(basepath, dirtree_file, yes)\n createDirectoryTree(basepath, dirtree_file)\n if sfv is True or default is True:\n sfv_file = f\"{basepath.name}.sfv\"\n checkFileExists(basepath, sfv_file, yes)\n createSfv(basepath, sfv_file)\n if filetree is True or default is True:\n csvtree_file = f\"{basepath.name}_file_tree.csv\"\n jsontree_file = f\"{basepath.name}_file_tree.json\"\n checkFileExists(basepath, jsontree_file, yes)\n checkFileExists(basepath, csvtree_file, yes)\n createFileTree(basepath, jsontree_file, csvtree_file)\n if meta is True or default is True:\n metadata_file = f\"{basepath.name}_metadata.json\"\n checkFileExists(basepath, metadata_file, yes)\n createMetadata(basepath, metadata_file)\n if newmeta is True:\n createNewMetadata(basepath)\n filesCache.cache_clear()\n getFileInfo.cache_clear()\n killTika()\n\n stop_time = time()\n print(f\"Finished in {round(stop_time-start_time, 2)} seconds\")","def alternative_miner(filepath, minFrequency):\n\t# TODO: either second implementation of the apriori algorithm or implementation of the depth first search algorithm\n\tprint(\"Not implemented\")"],"string":"[\n \"def _build_file_tree(self):\\n # Build file tree with packmode and weigth info (# of file in the packmode)\\n root = {\\\"packmode\\\": None, \\\"weight\\\": None, \\\"children\\\": {}}\\n for filepath, packmode in self.override_packmode_map.items():\\n node = root\\n for part in filepath:\\n node = node[\\\"children\\\"].setdefault(\\n part, {\\\"packmode\\\": None, \\\"weight\\\": None, \\\"children\\\": {}}\\n )\\n node[\\\"weight\\\"] = 1\\n node[\\\"packmode\\\"] = packmode\\n return root\",\n \"def _resolve_archive_depth(self, product_path):\\n archive_depth = getattr(self.config, \\\"archive_depth\\\", 1)\\n count = 1\\n while count < archive_depth:\\n product_path = os.path.join(product_path, os.listdir(product_path)[0])\\n count += 1\\n return product_path\",\n \"def DEFAULT_MAX_DEPTH(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def max_depth(self): # DirObj.max_depth\\n md=self.depth\\n if len(self.subdirs.keys()):\\n for name, entry in self.subdirs.iteritems():\\n if not entry.deleted:\\n td = entry.max_depth()\\n if td > md:\\n md=td\\n return md\\n elif len(self.files.keys()):\\n return md + 1\\n else:\\n return md\",\n \"def update_max_search_depth(self, depth):\\n if self.max_search_depth < depth:\\n self.max_search_depth = depth\",\n \"def DEFAULT_MAX_DEPTH_DIFF(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def _write_overrides(\\n self, node, parent=None, parent_packmode=None, path_parts=tuple(), root=None\\n ):\\n if root is None:\\n root = node\\n if (parent is root) or (\\n parent_packmode and node[\\\"packmode\\\"] != parent_packmode\\n ):\\n self.overrides[str(PurePath(*path_parts))] = node[\\\"packmode\\\"]\\n for key, child in node[\\\"children\\\"].items():\\n self._write_overrides(\\n node=child,\\n parent=node,\\n parent_packmode=node[\\\"packmode\\\"],\\n path_parts=path_parts + (key,),\\n root=root,\\n )\",\n \"def DEFAULT_MIN_DEPTH(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def __init__(self, shouldPack = True):\\n self.shouldPack = shouldPack\\n \\n for i in range(consts.IMAGE_NUMBEROF_DIRECTORY_ENTRIES):\\n dir = Directory()\\n dir.name.value = dirs[i]\\n self.append(dir)\",\n \"def reset_max_depth(self) -> None:\\n # The max depth is now calculated on the fly, so this is a no-op.\\n pass\",\n \"def reduce_files_type(target_path=None):\\n\\n global FILELIST\\n i = 0\\n for path, subdirs, files in os.walk(target_path):\\n for name in files:\\n fn = os.path.join(path, name)\\n if valid_package(filename=fn):\\n f = File(fn)\\n FILELIST[f.get_md5()] = os.path.join(path, name)\\n i = i + 1\\n\\n return i\",\n \"def _distribute_files(self, distribution='one'):\\n for k, files in self.file_lists.items():\\n self.idle[k] = False\\n if distribution.lower() == 'single':\\n self.distribution_comms[k] = None\\n if self.comm.rank >= 1:\\n self.local_file_lists[k] = None\\n self.idle[k] = True\\n else:\\n self.local_file_lists[k] = files\\n elif distribution.lower() == 'even':\\n if len(files) <= self.comm.size:\\n if self.comm.rank >= len(files):\\n self.local_file_lists[k] = None\\n self.distribution_comms[k] = None\\n self.idle[k] = True\\n else:\\n self.local_file_lists[k] = [files[self.comm.rank],]\\n self.distribution_comms[k] = self.comm.Create(self.comm.Get_group().Incl(np.arange(len(files))))\\n else:\\n files_per = int(np.floor(len(files) / self.comm.size))\\n excess_files = int(len(files) % self.comm.size)\\n if self.comm.rank >= excess_files:\\n self.local_file_lists[k] = list(files[int(self.comm.rank*files_per+excess_files):int((self.comm.rank+1)*files_per+excess_files)])\\n else:\\n self.local_file_lists[k] = list(files[int(self.comm.rank*(files_per+1)):int((self.comm.rank+1)*(files_per+1))])\\n self.distribution_comms[k] = self.comm\",\n \"def packBest(self, autorotate=False):\\n\\n sheets, extraBlocks = [], []\\n score = 0\\n\\n best = {\\n 'score': 0,\\n 'area': 10000000000000000000,\\n 'count': 10000000000000,\\n 'eff': 0\\n }\\n \\n # Sort Functions\\n def sortHeight(block):\\n return (block.w, block.h, block.image.checksum)\\n\\n def sortWidth(block):\\n return (block.h, block.w, block.image.checksum)\\n\\n def sortArea(block):\\n return (block.w * block.h, block.w, block.h, block.image.checksum)\\n\\n sorts = [sortHeight, sortWidth, sortArea]\\n rotationDiff = [(0, 0), (1.4, 0), (0, 1.4), (1.4, 1.4)] # rotate by 90 degrees if either b / a > value\\n\\n # Determine minimum size for spritesheet generation\\n # by averaging the widths and heights of all images\\n # while taking the ones in the sorted middile higher into account\\n # then the ones at the outer edges of the spectirum\\n\\n\\n l = len(self.files)\\n mw = [(l - abs(i - l / 2)) / l * v for i, v in enumerate(sorted([i.width for i in self.files]))]\\n mh = [(l - abs(i - l / 2)) / l * v for i, v in enumerate(sorted([i.height for i in self.files]))]\\n\\n minWidth = max(128, math.pow(2, math.ceil(math.log(sum(mw) / l, 2))))\\n minHeight = max(128, math.pow(2, math.ceil(math.log(sum(mh) / l, 2))))\\n\\n #baseArea = sum([(l - abs(i - l / 2)) / l * v for i, v in enumerate(sorted([i.width * i.height for i in self.files]))])\\n\\n\\n # try to skip senseless generation of way to small sprites\\n baseArea = sum([minWidth * minHeight for i in self.files])\\n while baseArea / (minWidth * minHeight) >= 20: # bascially an estimate of the number of sheets needed\\n minWidth *= 2\\n minHeight *= 2\\n\\n Console.debug('- Minimal size is %dx%dpx' % (minWidth, minHeight))\\n\\n sizes = list(itertools.product([w for w in [128, 256, 512, 1024, 2048] if w >= minWidth],\\n [h for h in [128, 256, 512, 1024, 2048] if h >= minHeight]))\\n\\n if autorotate:\\n methods = list(itertools.product(sorts, sizes, rotationDiff))\\n\\n else:\\n methods = list(itertools.product(sorts, sizes, [(0, 0)]))\\n\\n Console.debug('Packing sprite sheet variants...')\\n Console.indent()\\n\\n scores = []\\n for sort, size, rotation in methods:\\n\\n # pack with current settings\\n sh, ex, _ = self.pack(size[0], size[1], sort, silent=True, rotate=rotation)\\n\\n if len(sh):\\n score = PackerScore(sh, ex)\\n\\n # Determine score, highest wins\\n scores.append(score)\\n\\n else:\\n Console.debug('No sprite sheets generated, no image fit into the sheet')\\n\\n Console.outdent()\\n scores.sort()\\n\\n Console.debug('Generated the following sheets:')\\n for i in scores:\\n Console.debug('- ' + str(i))\\n\\n sheets, external = scores[0].data()\\n \\n if external:\\n for block in external:\\n Console.info('Ignored file %s (%dx%dpx)' % (block.image.relPath, block.w, block.h))\\n \\n return sheets, len(scores)\",\n \"def walk(self, path):\\n # strip trailing slashes, they are not needed\\n path = path.rstrip(os.path.sep)\\n\\n # check if a weight has been provided for this argument\\n weight_adjust, path = check_level(path)\\n\\n if os.path.isfile(path):\\n if self.args.stagger_paths:\\n weight_adjust = weight_adjust + self.stagger\\n new_file = FileObj(path, self.args, self.db,\\n weight_adjust=weight_adjust)\\n if self.args.stagger_paths:\\n self.stagger = self.stagger + new_file.depth\\n self.contents[path] = new_file\\n elif issocket(path):\\n print('WARNING: Skipping a socket ' + path, file=sys.stderr)\\n elif os.path.isdir(path):\\n if self.args.stagger_paths:\\n weight_adjust = weight_adjust + self.stagger\\n top_dir_entry = DirObj(path, self.args, weight_adjust)\\n self.contents[path] = top_dir_entry\\n for dir_name, _, file_list in os.walk(path, topdown=False):\\n # we do not walk into or add names from our ignore list.\\n # We wont delete them if they are leaf nodes and we wont\\n # count them towards parent nodes.\\n if os.path.basename(dir_name) in DELETE_DIR_LIST:\\n continue\\n\\n dir_entry = top_dir_entry.place_dir(\\n dir_name, weight_adjust)\\n if dir_entry is None:\\n continue\\n\\n for fname in file_list:\\n pname = os.path.join(dir_entry.pathname, fname)\\n if issocket(pname):\\n print('WARNING: Skipping a socket ' +\\n pname, file=sys.stderr)\\n elif os.path.basename(fname) not in DELETE_FILE_LIST:\\n new_file = FileObj(fname, self.args, self.db,\\n parent=dir_entry,\\n weight_adjust=weight_adjust)\\n if new_file.bytes == 0 and not self.args.keep_empty_files:\\n new_file.to_delete = True\\n dir_entry.files[fname] = new_file\\n\\n if self.args.stagger_paths:\\n self.stagger = self.stagger + top_dir_entry.max_depth()\\n else:\\n print(\\\"\\\\nFATAL ERROR: dont know what this is: \\\" +\\n path, file=sys.stderr)\\n sys.exit()\",\n \"def getPreferredLevel(self, level):\\n level = max(0, min(level, self.levels - 1))\\n baselevel = level\\n while self._tiffDirectories[level] is None and level < self.levels - 1:\\n level += 1\\n while level - baselevel >= self._maxSkippedLevels:\\n level -= self._maxSkippedLevels\\n return level\",\n \"def pack(backend_name, patterns, size, minimum, yes):\\n # Load the backend\\n backend = get_backend(backend_name)\\n # Find the paths\\n click.echo(\\\"Scanning files... \\\", nl=False)\\n paths, size_used = Scanner(config.root_path, patterns).unstored_paths(\\n config.index, size * (1024 ** 3)\\n )\\n click.secho(\\\"Done\\\", fg=\\\"green\\\")\\n if not paths:\\n click.secho(\\\"No files found to add.\\\", fg=\\\"yellow\\\")\\n return\\n # Print what we found\\n for path in paths:\\n click.echo(\\\"> \\\" + click.style(path, fg=\\\"blue\\\"))\\n click.echo(\\\"%s files, %s\\\" % (len(paths), human_size(size_used)))\\n # Prompt to continue\\n if not yes:\\n if not click.confirm(\\\"Proceed with build?\\\"):\\n return\\n click.echo()\\n # Select an unused archive ID\\n archive_id = config.index.new_archive_id()\\n # Pack the volume\\n archive = Archive.from_files(archive_id, paths, config.root_path)\\n click.echo(f\\\"Archive is {archive.id}, size {human_size(archive.size)}\\\")\\n if archive.size < minimum * (1024 ** 3):\\n click.echo(\\\"Archive too small, quitting\\\")\\n sys.exit(1)\\n backend.archive_store(config.root_path, archive)\\n click.echo(\\\"Archive stored\\\")\\n config.index.add_archive(archive, backend_name)\\n click.echo(\\\"Archive indexed\\\")\",\n \"def chgrp_perms_updown( path, group='climatew' ):\\n global std_file_perms, std_dir_perms\\n # First go down\\n for (root,dirs,files) in os.walk(path):\\n chgrp_perms( root, group, std_dir_perms )\\n for file in files:\\n chgrp_perms( os.path.join(root,file), group, std_file_perms )\\n dir = path\\n try:\\n while len(dir)>21: # len(\\\"/p/css03/esgf_publish\\\")\\n chgrp_perms( dir, group, std_dir_perms )\\n dir = os.path.split(dir)[0]\\n except: # If we don't have write permission, we're finished.\\n pass\",\n \"def initiallize_buffer(self):\\n assert os.path.isdir(self.directory)\\n #sorting files topologically, files' format is -> data_num.h5 \\n files_list = sorted(os.listdir(self.directory + '/' + self.name + '/'), key = lambda x: int(x.split(\\\"_\\\")[1].split(\\\".\\\")[0]))\\n self.files_counter = 0\\n if files_list != []: \\n for file_name in files_list:\\n self.memorize(name = file_name, error = 1)\\n self.files_counter += 1\\n self.files_tracker = file_name\\n else:\\n self.files_tracker = 'data_-1.h5'\",\n \"def old_create_dir_struct(self, create_first_rev_folder=\\\"True\\\"):\\n # | - create_dir_struct\\n for job in self.job_var_lst:\\n if create_first_rev_folder == \\\"True\\\":\\n path = self.var_lst_to_path(job) + \\\"_1\\\"\\n elif create_first_rev_folder == \\\"False\\\":\\n path = self.var_lst_to_path(job)\\n\\n path = self.root_dir + \\\"/\\\" + path\\n\\n if os.path.exists(path):\\n mess = \\\"Path already exists: \\\" + str(path)\\n print(mess)\\n\\n elif not os.path.exists(path):\\n os.makedirs(path)\\n\\n # | - Creating Variable Text Files Through Directoy Structure\\n for job in self.job_var_lst:\\n path = self.var_lst_to_path(job)\\n path = self.root_dir + \\\"/\\\" + path\\n\\n file_name = path + \\\"job_dir_level\\\"\\n with open(file_name, \\\"w\\\") as fle:\\n fle.write(\\\"\\\\n\\\")\\n\\n for root, dirs, files in os.walk(self.root_dir + \\\"/data/\\\"):\\n if \\\"job_dir_level\\\" in files:\\n continue\\n\\n else:\\n prop_lst = []\\n for folder in dirs:\\n tmp = self.sep.join(folder.split(self.sep)[1:])\\n\\n prop = self.__replace_p_for_per__(tmp)\\n prop = self.__replace_negative_for_n__(prop)\\n prop_lst.append(prop)\\n\\n for key, value in self.level_entries.items():\\n if set(prop_lst) == set(map(str, value)):\\n\\n file_name = root + \\\"/properties.txt\\\"\\n with open(file_name, \\\"w\\\") as fle:\\n fle.write(key + \\\"\\\\n\\\")\\n\\n # f = open(root + \\\"/properties.txt\\\", \\\"w\\\")\\n # f.write(key + \\\"\\\\n\\\")\\n # f.close()\\n # __|\\n\\n # self.__create_dir_structure_file__()\\n\\n # | - folders_exist attribute should be True from now on\\n file_name = self.root_dir + \\\"/jobs_bin/.folders_exist\\\"\\n with open(file_name, \\\"w\\\") as fle:\\n fle.write(\\\"\\\\n\\\")\\n\\n self.folders_exist = self.__folders_exist__(True)\\n # __|\\n\\n # __|\",\n \"def get_desired_depth(file_name, tree, desired_depth):\\n node_keys = []\\n get_nodes_at_depth(tree.root, desired_depth, node_keys)\\n generate_file(file_name, node_keys)\\n print(\\\"File '\\\" + file_name + \\\"' generated with keys at depth: :\\\", desired_depth)\",\n \"def max_depth(self) -> int:\\n return 0\",\n \"def generate_tree(self, max_depth = None):\\n\\n if max_depth is None:\\n max_depth = self.tree.max_depth\\n else:\\n max_depth -= 1\\n if max_depth == 0:\\n return\\n self.generate_children()\\n if self.tree.remove:\\n os.unlink(self.source_filename)\\n for child in self.children:\\n if child.count > self.tree.max_count:\\n child.generate_tree(max_depth)\",\n \"def __init__(self, dirname, defmode='r'):\\n self.name = dirname\\n self.defmode = defmode\\n\\n self.items = []\\n\\n for i in os.listdir(dirname):\\n if os.path.isdir(os.path.join(dirname, i)):\\n self.items.append(Tree(os.path.join(dirname, i), defmode))\\n\\n else:\\n self.items.append(open(os.path.join(dirname, i), defmode))\\n\\n self._dict = self.to_dict()\",\n \"def convert_dir(self) -> int:\\n old_classifiers: List[Classifier] = self.get_entities_by_entity_type(\\n self.pack.classifiers, FileType.OLD_CLASSIFIER\\n )\\n intersection_fields = self.get_classifiers_schema_intersection_fields()\\n for old_classifier in old_classifiers:\\n self.create_classifier_from_old_classifier(\\n old_classifier, intersection_fields\\n )\\n self.create_mapper_from_old_classifier(old_classifier)\\n\\n return 0\",\n \"def compress(self, src, dst):\\n info = readelf_get_info(src)\\n starting_size = os.path.getsize(src)\\n if starting_size != info[\\\"size\\\"]:\\n raise RuntimeError(\\\"size of file '%s' differs from header claim: %i != %i\\\" %\\n (src, starting_size, info[\\\"size\\\"]))\\n rfd = open(src, \\\"rb\\\")\\n wfd = open(dst, \\\"wb\\\")\\n data = rfd.read(starting_size)\\n wfd.write(data[info[\\\"entry\\\"]:])\\n rfd.close()\\n wfd.close()\\n self.__uncompressed_size = len(data) - info[\\\"entry\\\"]\\n if is_verbose():\\n print(\\\"Wrote compressable program block '%s': %i bytes\\\" % (dst, self.__uncompressed_size))\\n self.__contexts = []\\n self.__weights = []\\n (so, se) = run_command([self.__command, dst])\\n lines = so.split(\\\"\\\\n\\\")\\n for ii in lines:\\n terms = ii.split()\\n if terms and terms[0].startswith(\\\"Final\\\"):\\n compressed_size = int(terms[1])\\n for jj in terms[2:]:\\n individual_term = jj.split(\\\"*\\\")\\n self.__weights += [int(individual_term[0], 10)]\\n self.__contexts += [int(individual_term[1], 16)]\\n if is_verbose():\\n print(\\\"Program block compressed into '%s': %i bytes\\\" % (dst + \\\".pack\\\", compressed_size))\\n print(\\\"Compression weights: %s\\\" % (str(self.__weights)))\\n print(\\\"Compression contexts: %s\\\" % (str(self.__contexts)))\\n rfd = open(dst + \\\".pack\\\", \\\"rb\\\")\\n compressed_contexts = []\\n compressed_weights = []\\n uncompressed_size = rfd.read(4)\\n uncompressed_size = (struct.unpack(\\\"I\\\", uncompressed_size))[0]\\n if uncompressed_size != self.__uncompressed_size:\\n raise RuntimeError(\\\"size given to packer does not match size information in file: %i != %i\\\" %\\n (self.__uncompressed_size, uncompressed_size))\\n context_count = rfd.read(1)\\n context_count = (struct.unpack(\\\"B\\\", context_count))[0]\\n for ii in range(context_count):\\n compressed_weights += struct.unpack(\\\"B\\\", rfd.read(1))\\n for ii in range(context_count):\\n compressed_contexts += struct.unpack(\\\"B\\\", rfd.read(1))\\n if compressed_contexts != self.__contexts:\\n raise RuntimeError(\\\"contexts reported by packer do not match context information in file: %s != %s\\\" %\\n (str(self.__contexts), str(compressed_contexts)))\\n if compressed_weights != self.__weights:\\n raise RuntimeError(\\\"weights reported by packer do not match weight information in file: %s != %s\\\" %\\n (str(self.__weights), str(compressed_weights)))\\n read_data = rfd.read()\\n rfd.close()\\n if len(read_data) != compressed_size:\\n raise RuntimeError(\\\"size reported by packer does not match length of file: %i != %i\\\" %\\n (compressed_size, len(read_data)))\\n self.__data = []\\n for ii in read_data:\\n self.__data += struct.unpack(\\\"B\\\", ii)\",\n \"def scan_repack_dir(file_list):\\n\\t# TODO: Figure out elegant way to incorporate size comparison to this without any extra loops\\n\\tfiles_to_repack = [ item for item in os.listdir(\\\"repack\\\") if os.path.isfile(os.path.join(\\\"repack\\\", item)) ] # Aww yiss, list comprehensions\\n\\tfor file in file_list:\\n\\t\\tif file.filename in files_to_repack:\\n\\t\\t\\tfile.should_repack = True\\n\\t\\t\\tsize_difference = compare_file_size(file.filename, file.size)\\n\\t\\t\\tif size_difference:\\n\\t\\t\\t\\tfile.new_size = file.size + size_difference\",\n \"def set_option_max_depth(self, integer, apikey=''):\\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/action/setOptionMaxDepth/', {'Integer': integer, 'apikey': apikey})))\",\n \"def select_best(src_dirs, dst_dir, op_name):\\n\\n def _copy_file(src_path, dst_path):\\n try:\\n if os.path.isfile(dst_path):\\n os.remove(dst_path)\\n except OSError:\\n pass\\n\\n try:\\n shutil.copy(src_path, dst_path)\\n except PermissionError:\\n # If dst_path already exits and only has READ permission\\n pass\\n\\n max_block_dim = 1\\n max_block_dim_idx = -1\\n for i, src_dir in enumerate(src_dirs):\\n o_path = os.path.join(src_dir, op_name + \\\".o\\\")\\n json_path = os.path.join(src_dir, op_name + \\\".json\\\")\\n if os.path.isfile(o_path) and os.path.isfile(json_path):\\n with open(json_path, 'r') as f:\\n json_str = f.read()\\n json_dict = json.loads(json_str)\\n if json_dict[\\\"blockDim\\\"] >= max_block_dim:\\n max_block_dim_idx = i\\n max_block_dim = json_dict[\\\"blockDim\\\"]\\n if max_block_dim_idx >= 0:\\n o_path = os.path.join(src_dirs[max_block_dim_idx], op_name + \\\".o\\\")\\n json_path = os.path.join(src_dirs[max_block_dim_idx], op_name + \\\".json\\\")\\n _copy_file(o_path, os.path.join(dst_dir, op_name + \\\".o\\\"))\\n _copy_file(json_path, os.path.join(dst_dir, op_name + \\\".json\\\"))\\n logger.info(\\\"{}, best compile result dir: {}\\\".format(op_name, src_dirs[max_block_dim_idx]))\\n return True\\n logger.info(\\\"{}, best compile result dir not found\\\".format(op_name))\\n return False\",\n \"def test_level_file_default(self):\\n\\n # --level default (file) - no tax\\n params = self.default_params.copy()\\n params[\\\"db_prefix\\\"] = self.results_dir + \\\"test_level_file_default\\\"\\n params[\\\"input_target\\\"] = \\\"file\\\"\\n cfg = Config(\\\"build-custom\\\", **params)\\n self.assertTrue(run_ganon(cfg, params[\\\"db_prefix\\\"]), \\\"ganon build-custom run failed\\\")\\n res = build_sanity_check_and_parse(vars(cfg))\\n self.assertIsNotNone(res, \\\"ganon build-custom sanity check failed\\\")\\n\\n # --level default (file) NCBI\\n params = self.default_params.copy()\\n params[\\\"db_prefix\\\"] = self.results_dir + \\\"test_level_file_default_ncbi\\\"\\n params[\\\"input_target\\\"] = \\\"file\\\"\\n params[\\\"taxonomy\\\"] = \\\"ncbi\\\"\\n params[\\\"taxonomy_files\\\"] = data_dir + \\\"build-custom/taxdump.tar.gz\\\"\\n params[\\\"ncbi_file_info\\\"] = data_dir + \\\"build-custom/assembly_summary.txt\\\"\\n params[\\\"genome_size_files\\\"] = data_dir + \\\"build-custom/species_genome_size.txt.gz\\\"\\n cfg = Config(\\\"build-custom\\\", **params)\\n self.assertTrue(run_ganon(cfg, params[\\\"db_prefix\\\"]), \\\"ganon build-custom run failed\\\")\\n res = build_sanity_check_and_parse(vars(cfg))\\n self.assertIsNotNone(res, \\\"ganon build-custom sanity check failed\\\")\\n\\n # --level default (file) GTDB\\n params = self.default_params.copy()\\n params[\\\"db_prefix\\\"] = self.results_dir + \\\"test_level_file_default_gtdb\\\"\\n params[\\\"input_target\\\"] = \\\"file\\\"\\n params[\\\"taxonomy\\\"] = \\\"gtdb\\\"\\n params[\\\"taxonomy_files\\\"] = [data_dir + \\\"build-custom/ar53_taxonomy.tsv.gz\\\",\\n data_dir + \\\"build-custom/bac120_taxonomy.tsv.gz\\\"]\\n params[\\\"genome_size_files\\\"] = [data_dir + \\\"build-custom/ar53_metadata.tar.gz\\\",\\n data_dir + \\\"build-custom/bac120_metadata.tar.gz\\\"]\\n cfg = Config(\\\"build-custom\\\", **params)\\n self.assertTrue(run_ganon(cfg, params[\\\"db_prefix\\\"]), \\\"ganon build-custom run failed\\\")\\n res = build_sanity_check_and_parse(vars(cfg))\\n self.assertIsNotNone(res, \\\"ganon build-custom sanity check failed\\\")\",\n \"def package():\\n \\n hou.hipFile.save()\\n currentHip = hou.expandString(hou.hipFile.name())\\n\\n # create a temp directory we are going to fill with crap\\n tempFilePath = tempfile.mkdtemp()\\n \\n otls = os.path.join(tempFilePath, \\\"otls\\\")\\n os.mkdir(otls)\\n files = os.path.join(tempFilePath, \\\"files\\\")\\n os.mkdir(files)\\n \\n # Get all the external references to the hipfile\\n fileOnDisk = hou.fileReferences()\\n\\n # loop and do what comes natural.\\n for _file in fileOnDisk:\\n\\n parm = _file[0]\\n filepath = _file[1]\\n \\n # if its a otl we need to store it.\\n if filepath.endswith(\\\".otl\\\"):\\n \\n shutil.copy(hou.expandString(filepath), otls)\\n \\n else:\\n \\n if not os.path.isfile(hou.expandString(filepath)): \\n \\n continue\\n \\n # create a directory in files and save 1 file to that location\\n tmpFileName = os.path.basename(hou.expandString(filepath))\\n tmpFileDir = os.path.basename(os.path.dirname(hou.expandString(filepath)))\\n path = os.path.join(files, tmpFileDir)\\n \\n if not os.path.isdir(path):\\n \\n os.mkdir(path)\\n\\n shutil.copy(hou.expandString(filepath), os.path.join(path, os.path.basename(hou.expandString(filepath))))\\n\\n try:\\n \\n if not parm.node().isLocked():\\n \\n parm.set(os.path.join(path.replace(tempFilePath, \\\"$HIP\\\"), tmpFileName))\\n \\n except hou.PermissionError: \\n \\n logging.warning(\\\"Error hardening parm :\\\" + str(parm.name()) + \\\"on node \\\" +parm.node().path())\\n\\n hou.hipFile.save(os.path.join(tempFilePath, os.path.basename(hou.expandString(hou.hipFile.name()))))\\n # Load the source hipfile\\n hou.hipFile.load(currentHip)\\n \\n # create a zipfile and package everything. then copy it to the home.\\n zipfileLoc = zipdir(tempFilePath)\\n shutil.move(zipfileLoc, os.path.join(hou.expandString(\\\"~\\\"), \\\"package.zip\\\"))\\n shutil.rmtree(tempFilePath)\",\n \"def option_max_depth(self):\\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/view/optionMaxDepth/')))\",\n \"def handle_package(self, prime_dir, bases_config: BasesConfiguration):\\n emit.progress(\\\"Creating the package itself\\\")\\n zipname = format_charm_file_name(self.config.name, bases_config)\\n zipfh = zipfile.ZipFile(zipname, \\\"w\\\", zipfile.ZIP_DEFLATED)\\n for dirpath, _dirnames, filenames in os.walk(prime_dir, followlinks=True):\\n dirpath = pathlib.Path(dirpath)\\n for filename in filenames:\\n filepath = dirpath / filename\\n zipfh.write(str(filepath), str(filepath.relative_to(prime_dir)))\\n\\n zipfh.close()\\n return zipname\",\n \"def test_build_children_state_default_partial(self):\\n r_a = SystemFile(\\\"a\\\", 300, True)\\n r_aa = SystemFile(\\\"aa\\\", 100, True)\\n r_a.add_child(r_aa)\\n r_aaa = SystemFile(\\\"aaa\\\", 100, False)\\n r_aa.add_child(r_aaa)\\n r_ab = SystemFile(\\\"ab\\\", 200, False)\\n r_a.add_child(r_ab)\\n\\n l_a = SystemFile(\\\"a\\\", 150, True)\\n l_aa = SystemFile(\\\"aa\\\", 50, True)\\n l_a.add_child(l_aa)\\n l_aaa = SystemFile(\\\"aaa\\\", 50, False)\\n l_aa.add_child(l_aaa)\\n l_ab = SystemFile(\\\"ab\\\", 100, False)\\n l_a.add_child(l_ab)\\n\\n self.model_builder.set_remote_files([r_a])\\n self.model_builder.set_local_files([l_a])\\n model = self.model_builder.build_model()\\n m_a = model.get_file(\\\"a\\\")\\n self.assertEqual(ModelFile.State.DEFAULT, m_a.state)\\n m_a_ch = {m.name: m for m in model.get_file(\\\"a\\\").get_children()}\\n m_aa = m_a_ch[\\\"aa\\\"]\\n self.assertEqual(ModelFile.State.DEFAULT, m_aa.state)\\n m_aaa = m_aa.get_children()[0]\\n self.assertEqual(ModelFile.State.DEFAULT, m_aaa.state)\\n m_ab = m_a_ch[\\\"ab\\\"]\\n self.assertEqual(ModelFile.State.DEFAULT, m_ab.state)\",\n \"def process_tree(self, src, dst):\\n srcset_fmt = self.kw['image_srcset_format']\\n srcset_sizes_all = self.kw['image_srcset_sizes']\\n base_len = len(src.split(os.sep))\\n for root, dirs, files in os.walk(src, followlinks=True):\\n root_parts = root.split(os.sep)\\n dst_dir = os.path.join(dst, *root_parts[base_len:])\\n utils.makedirs(dst_dir)\\n for src_name in files:\\n if (not src_name.lower().endswith(tuple(self.image_ext_list)) and not src_name.upper().endswith(tuple(self.image_ext_list))):\\n continue\\n dst_file = os.path.join(dst_dir, src_name)\\n src_file = os.path.join(root, src_name)\\n srcset_name, srcset_ext = os.path.splitext(src_name)\\n\\n # Find out the width of the image so we only resize up to that size\\n try:\\n src_width = Image.open(src_file).size[0]\\n except UnidentifiedImageError:\\n # e.g. for SVGs: we don't need srcsets\\n src_width = 1\\n # then trim our list of sizes to only those below the image width:\\n srcset_sizes = [ size for size in srcset_sizes_all if (size < src_width) ]\\n \\n # Create the list of filenames, starting with the \\\"max_sized\\\" version that bears the same name as the original file:\\n dsts = [dst_file]\\n\\n # Now add all the other filenames, based on their size:\\n for srcset_size in srcset_sizes:\\n srcset_size_file = os.path.join(dst_dir, srcset_fmt.format(\\n name = srcset_name,\\n size = srcset_size,\\n ext = srcset_ext,\\n ))\\n dsts.append(srcset_size_file)\\n\\n # If we have extra output formats for images, we need to add them to the list as well:\\n for extra_format in self.kw['extra_image_extensions']:\\n # First the largest / default image:\\n dsts.append(os.path.join(dst_dir, srcset_name + extra_format))\\n \\n # Then the smaller ones:\\n for srcset_size in srcset_sizes:\\n srcset_size_file = os.path.join(dst_dir, srcset_fmt.format(\\n name = srcset_name,\\n size = srcset_size,\\n ext = extra_format,\\n ))\\n dsts.append(srcset_size_file)\\n \\n yield {\\n 'name': dst_file,\\n 'file_dep': [src_file],\\n 'targets': dsts,\\n 'actions': [(self.process_image, (src_file, dsts, srcset_sizes))],\\n 'clean': True,\\n }\",\n \"def main(args):\\n\\n for dir in args.dirs:\\n # prepdir = mdssprep.Directory(dir,exclude=['file_*3*','file_2??'],include=['file_*5*'],maxarchivesize=mdssprep.one_meg*200.,minsize=mdssprep.one_meg*100.)\\n prepdir = mdssprep.Directory(dir)\\n prepdir.archive(dryrun=False)\",\n \"def bundle(target_path,\\n bundle_path,\\n toplevel,\\n name, workdir,\\n exn, ext, exf,\\n showtree=True):\\n _start_time = time.time()\\n\\n def _build_directory_structure(project_root, exn, ext, exf):\\n \\\"\\\"\\\"\\n STEP 1.1: Walk the target directory. Build file/dir\\n list excluding exn, ext, and exf entries where applicable.\\n \\\"\\\"\\\"\\n structure = {}\\n num_file = 0\\n num_dir = 0\\n\\n num_file_exc = 0\\n num_dir_exc = 0\\n\\n total_size = 0\\n\\n root = project_root.rstrip(os.sep)\\n start = root.rfind(os.sep) + 1\\n for path, dirs, files in os.walk(root):\\n # excludes\\n for dn in dirs:\\n if dn in exf:\\n dirs.remove(dn)\\n num_dir_exc += 1\\n for fn in files:\\n if fn in exn:\\n files.remove(fn)\\n num_file_exc += 1\\n for fn in files:\\n extension = fn.split('.')[-1]\\n if extension in ext:\\n files.remove(fn)\\n num_file_exc += 1\\n\\n folders = path[start:].split(os.sep)\\n subdir = dict.fromkeys(files)\\n\\n num_file += len(files)\\n num_dir += len(dirs)\\n\\n # coalate data on files\\n for fn in files:\\n full_path = os.path.join(path, fn)\\n total_size += os.stat(full_path).st_size\\n with open(full_path, 'rb') as f:\\n # get byte data\\n _tmp_data = f.read()\\n # get md5 checksum\\n # encode byte-stream to base64. installer will decode.\\n subdir[fn] = base64.b64encode(_tmp_data)\\n\\n # add to structure dict\\n parent = reduce(dict.get, folders[:-1], structure)\\n parent[folders[-1]] = subdir\\n\\n return structure, num_dir, num_file, (num_dir_exc, num_file_exc), total_size\\n\\n _write(\\\"bundle\\\")\\n _write(\\\" directory structure ... \\\", False)\\n structure, num_dir, num_file, exc, size = _build_directory_structure(target_path, exn, ext, exf)\\n _write(\\\"ok.\\\")\\n _write(\\\" found {0} directories, {1} files; {2:.2f}Mb ({3} bytes)\\\".format(num_dir, num_file, float(size)/1000.0, size))\\n _write(\\\" (excluded {0} dir, {1} files)\\\".format(exc[0], exc[1]))\\n\\n # rename the toplevel\\n if toplevel != basename(target_path):\\n structure[toplevel] = structure[basename(target_path)]\\n del structure[basename(target_path)]\\n\\n # write out the tree\\n if showtree:\\n _write(\\\"structure:\\\")\\n _write(\\\"{0}\\\".format(_build_directory_structure_string(structure)))\\n\\n # construc the config dict\\n build_config = {\\n \\\"project_root\\\": abspath(target_path),\\n \\\"toplevel_rename\\\": toplevel,\\n \\\"project_name\\\": name,\\n \\\"excludes\\\": {\\n \\\"exn\\\": exn,\\n \\\"ext\\\": ext,\\n \\\"exf\\\": exf\\n },\\n \\\"num_file\\\": num_file,\\n \\\"num_dir\\\": num_dir,\\n \\\"bytesize\\\": size,\\n \\\"structure\\\": structure,\\n \\\"__workdir\\\": abspath(workdir)\\n }\\n\\n # dump the .bundle file as a json config\\n _write(\\\" writing project config to {0} ... \\\".format(bundle_path), False)\\n with open(bundle_path, 'w') as f:\\n json.dump(build_config, f,\\n sort_keys=True,\\n ensure_ascii=False,\\n indent=4)\\n _write(\\\"ok\\\")\\n _write(\\\"build completed, {0:.2f} seconds\\\".format(time.time() - _start_time))\\n\\n return build_config\",\n \"def createExtnNodes(self):\\n for parent, dirs, files in os.walk(self.destndir):\\n for fname in files:\\n filename = os.path.join(parent, fname)\\n if os.path.isfile(filename):\\n direntry=parent\\n #direntry=parent.replace(self.destndir,'',len(self.destndir))\\n #direntry = os.path.basename(os.path.abspath(parent))\\n self.appendSrcType(direntry, fname)\",\n \"def CountChildMetadata(self):\\n\\n assert self.dir\\n d = self.descendants = {(self.uid, self.gid, self.mode, None, self.selabel, self.capabilities): 1}\\n for i in self.children:\\n if i.dir:\\n for k, v in i.CountChildMetadata().iteritems():\\n d[k] = d.get(k, 0) + v\\n else:\\n k = (i.uid, i.gid, None, i.mode, i.selabel, i.capabilities)\\n d[k] = d.get(k, 0) + 1\\n\\n # Find the (uid, gid, dmode, fmode, selabel, capabilities)\\n # tuple that matches the most descendants.\\n\\n # First, find the (uid, gid) pair that matches the most\\n # descendants.\\n ug = {}\\n for (uid, gid, _, _, _, _), count in d.iteritems():\\n ug[(uid, gid)] = ug.get((uid, gid), 0) + count\\n ug = MostPopularKey(ug, (0, 0))\\n\\n # Now find the dmode, fmode, selabel, and capabilities that match\\n # the most descendants with that (uid, gid), and choose those.\\n best_dmode = (0, 0755)\\n best_fmode = (0, 0644)\\n best_selabel = (0, None)\\n best_capabilities = (0, None)\\n for k, count in d.iteritems():\\n if k[:2] != ug: continue\\n if k[2] is not None and count >= best_dmode[0]: best_dmode = (count, k[2])\\n if k[3] is not None and count >= best_fmode[0]: best_fmode = (count, k[3])\\n if k[4] is not None and count >= best_selabel[0]: best_selabel = (count, k[4])\\n if k[5] is not None and count >= best_capabilities[0]: best_capabilities = (count, k[5])\\n self.best_subtree = ug + (best_dmode[1], best_fmode[1], best_selabel[1], best_capabilities[1])\\n\\n return d\",\n \"def initDefault(self):\\n #--Package Only\\n self.archive = ''\\n self.modified = 0 #--Modified date\\n self.size = 0 #--size of archive file\\n self.crc = 0 #--crc of archive\\n self.type = 0 #--Package type: 0: unset/invalid; 1: simple; 2: complex\\n self.fileSizeCrcs = []\\n self.subNames = []\\n self.src_sizeCrcDate = {} #--For InstallerProject's\\n #--Dirty Update\\n self.dirty_sizeCrc = {}\\n #--Mixed\\n self.subActives = []\\n #--User Only\\n self.skipVoices = False\\n self.hasExtraData = False\\n self.comments = ''\\n self.group = '' #--Default from abstract. Else set by user.\\n self.order = -1 #--Set by user/interface.\\n self.isActive = False\\n self.espmNots = set() #--Lowercase esp/m file names that user has decided not to install.\\n #--Volatiles (unpickled values)\\n #--Volatiles: directory specific\\n self.refreshed = False\\n #--Volatile: set by refreshDataSizeCrc\\n self.readMe = self.packageDoc = self.packagePic = None\\n self.data_sizeCrc = {}\\n self.skipExtFiles = set()\\n self.skipDirFiles = set()\\n self.espms = set()\\n self.unSize = 0\\n #--Volatile: set by refreshStatus\\n self.status = 0\\n self.underrides = set()\\n self.missingFiles = set()\\n self.mismatchedFiles = set()\\n self.mismatchedEspms = set()\",\n \"def get_tree_size(thread, root, top, path, docs, sizes, inodes, depth=0, maxdepth=999):\\n global filecount\\n global skipfilecount\\n global inodecount\\n global dircount\\n global skipdircount\\n global total_doc_count\\n global warnings\\n\\n size = 0\\n size_du = 0\\n dirs = 0\\n files = 0\\n f_count = 0\\n d_count = 0\\n f_skip_count = 0\\n d_skip_count = 0\\n tot_doc_count = 0\\n parent_path = None\\n size_norecurs = 0\\n size_du_norecurs = 0\\n files_norecurs = 0\\n dirs_norecurs = 0\\n \\n # use alt scanner\\n # try to get stat info for dir path\\n if options.altscanner:\\n try:\\n d_stat = alt_scanner.stat(path)\\n except RuntimeError as e:\\n logmsg = '[{0}] ALT SCANNER ERROR: {1}'.format(thread, e)\\n logger.error(logmsg)\\n if logtofile: logger_warn.error(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n return 0, 0, 0, 0\\n except Exception as e:\\n logmsg = '[{0}] ALT SCANNER EXCEPTION: {1}'.format(thread, e)\\n logger.exception(logmsg)\\n if logtofile: logger_warn.exception(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n return 0, 0, 0, 0\\n else:\\n # try to get os stat info for dir path\\n try:\\n d_stat = os.stat(path)\\n except OSError as e:\\n logmsg = '[{0}] OS ERROR: {1}'.format(thread, e)\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n return 0, 0, 0, 0\\n \\n # restore times (atime/mtime)\\n if restore_times:\\n res, err = set_times(path, d_stat.st_atime, d_stat.st_mtime)\\n if not res:\\n logmsg = 'OS ERROR setting file times for {0} (error {1})'.format(path, err)\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n\\n # scan directory\\n try:\\n logger.debug('[{0}] Scanning path {1}...'.format(thread, path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] Scanning path {1}...'.format(thread, path))\\n for entry in os.scandir(path):\\n logger.debug('[{0}] Scanning dir entry {1}...'.format(thread, entry.path))\\n if options.vverbose:\\n logger.info('[{0}] Scanning dir entry {1}...'.format(thread, entry.path)) \\n \\n if entry.is_symlink():\\n logger.debug('[{0}] skipping symlink {1}'.format(thread, entry.path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] skipping symlink {1}'.format(thread, entry.path))\\n pass\\n elif entry.is_dir():\\n d_count += 1\\n if not dir_excluded(entry.path):\\n dirs += 1\\n dirs_norecurs += 1\\n if maxdepth > 0:\\n if depth < maxdepth:\\n # recurse into subdir\\n if not quit:\\n s, sdu, fc, dc = get_tree_size(thread, root, top, entry.path, docs, sizes, inodes, depth+1, maxdepth)\\n size += s\\n size_du += sdu\\n files += fc\\n dirs += dc\\n else:\\n logger.debug('[{0}] not descending {1}, maxdepth {2} reached'.format(\\n thread, entry.path, maxdepth))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] not descending {1}, maxdepth {2} reached'.format(\\n thread, entry.path, maxdepth))\\n else:\\n logger.debug('[{0}] skipping dir {1}'.format(thread, entry.path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] skipping dir {1}'.format(thread, entry.path))\\n d_skip_count += 1\\n else:\\n f_count += 1\\n if not file_excluded(entry.name):\\n f_stat = entry.stat()\\n # restore times (atime/mtime)\\n if restore_times and not options.altscanner:\\n ret = set_times(entry.path, f_stat.st_atime, f_stat.st_mtime)\\n if not ret:\\n with crawl_thread_lock:\\n warnings += 1\\n\\n fsize = f_stat.st_size\\n # calculate allocated file size (du size)\\n if IS_WIN:\\n fsize_du = fsize\\n elif options.altscanner:\\n fsize_du = f_stat.st_sizedu\\n else:\\n fsize_du = f_stat.st_blocks * blocksize\\n # set fsize_du to 0 if inode in inodes list (hardlink)\\n if f_stat.st_ino in inodes:\\n fsize_du = 0\\n # add inode to inodes list if hardlink count > 1\\n elif f_stat.st_nlink > 1:\\n with crawl_thread_lock:\\n inodes.append(f_stat.st_ino)\\n fmtime_sec = time.time() - f_stat.st_mtime\\n fctime_sec = time.time() - f_stat.st_ctime\\n fatime_sec = time.time() - f_stat.st_atime\\n\\n if not exc_empty_files or (exc_empty_files and fsize > 0):\\n if fsize >= minfilesize and \\\\\\n fmtime_sec > minmtime and \\\\\\n fmtime_sec < maxmtime and \\\\\\n fctime_sec > minctime and \\\\\\n fctime_sec < maxctime and \\\\\\n fatime_sec > minatime and \\\\\\n fatime_sec < maxatime:\\n size += fsize\\n size_norecurs += fsize\\n size_du += fsize_du\\n size_du_norecurs += fsize_du\\n files += 1\\n files_norecurs += 1\\n # get owner and group names\\n if IS_WIN:\\n # for windows just set both owner and group to 0, this is what scandir returns for Windows\\n # and there is no known fast way to get Windows file owner (pywin32 is slow)\\n owner = f_stat.st_uid\\n group = f_stat.st_gid\\n else:\\n owner, group = get_owner_group_names(f_stat.st_uid, f_stat.st_gid)\\n \\n # check for bad Unicode utf-8 characters\\n try:\\n if parent_path is None:\\n parent_path = get_parent_path(entry.path)\\n file_name = get_file_name(entry.name)\\n except UnicodeError:\\n if parent_path is None:\\n parent_path = get_parent_path(entry.path, ignore_errors=True)\\n file_name = get_file_name(entry.name, ignore_errors=True)\\n logmsg = '[{0}] UNICODE WARNING {1}'.format(thread, os.path.join(parent_path, file_name))\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n \\n # index doc dict\\n data = {\\n 'name': file_name,\\n 'extension': os.path.splitext(entry.name)[1][1:].lower(),\\n 'parent_path': parent_path,\\n 'size': fsize,\\n 'size_du': fsize_du,\\n 'owner': owner,\\n 'group': group,\\n 'mtime': datetime.utcfromtimestamp(int(f_stat.st_mtime)).isoformat(),\\n 'atime': datetime.utcfromtimestamp(int(f_stat.st_atime)).isoformat(),\\n 'ctime': datetime.utcfromtimestamp(int(f_stat.st_ctime)).isoformat(),\\n 'nlink': f_stat.st_nlink,\\n 'ino': str(f_stat.st_ino),\\n 'type': 'file'\\n }\\n\\n # check if using altscanner and if any additional meta data to add to data dict\\n if options.altscanner:\\n try:\\n extrameta_dict = alt_scanner.add_meta(entry.path, f_stat)\\n if extrameta_dict is not None:\\n data.update(extrameta_dict)\\n except Exception as e:\\n logmsg = '[{0}] ALT SCANNER EXCEPTION {1}'.format(thread, e)\\n logger.exception(logmsg)\\n if logtofile: logger_warn.exception(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n # check plugins for adding extra meta data to data dict\\n if plugins_enabled and plugins_files:\\n for plugin in plugins:\\n try:\\n # check if plugin is for file doc\\n if plugin.for_type('file'):\\n extrameta_dict = plugin.add_meta(entry.path, f_stat)\\n if extrameta_dict is not None:\\n data.update(extrameta_dict)\\n except (RuntimeWarning, RuntimeError) as e:\\n err_message = e.args[0]\\n if e.__class__ == RuntimeWarning:\\n logmsg = '[{0}] PLUGIN WARNING: {1}'.format(thread, err_message)\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n else:\\n logmsg = '[{0}] PLUGIN ERROR: {1}'.format(thread, err_message)\\n logger.error(logmsg)\\n if logtofile: logger_warn.error(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n extrameta_dict = e.args[1]\\n if extrameta_dict is not None:\\n data.update(extrameta_dict)\\n except Exception as e:\\n logmsg = '[{0}] PLUGIN EXCEPTION {1}'.format(thread, e)\\n logger.exception(logmsg)\\n if logtofile: logger_warn.exception(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n # add file doc to docs list and upload to ES once it reaches certain size\\n docs.append(data.copy())\\n doc_count = len(docs)\\n if doc_count >= es_chunksize:\\n start_bulk_upload(thread, root, docs)\\n tot_doc_count += doc_count\\n docs.clear()\\n\\n else:\\n f_skip_count += 1\\n logger.debug('[{0}] skipping file {1}'.format(thread, entry.path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] skipping file {1}'.format(thread, entry.path))\\n else:\\n f_skip_count += 1\\n logger.debug('[{0}] skipping file {1}'.format(thread, entry.path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] skipping file {1}'.format(thread, entry.path))\\n else:\\n f_skip_count += 1\\n logger.debug('[{0}] skipping file {1}'.format(thread, entry.path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] skipping file {1}'.format(thread, entry.path))\\n \\n # if not excluding empty dirs is set or exclude empty dirs is set but there are files or \\n # dirs in the current directory, index the dir\\n if not exc_empty_dirs or (exc_empty_dirs and (files > 0 or dirs > 0)):\\n # get owner and group names\\n if IS_WIN:\\n # for windows just set both owner and group to 0, this is what scandir returns for Windows\\n # and there is no known fast way to get Windows file owner (pywin32 is slow)\\n owner = d_stat.st_uid\\n group = d_stat.st_gid\\n else:\\n owner, group = get_owner_group_names(d_stat.st_uid, d_stat.st_gid)\\n \\n # check for bad Unicode utf-8 characters\\n try:\\n file_name = get_dir_name(path)\\n parent_path = get_parent_path(path)\\n except UnicodeError:\\n file_name = get_dir_name(path, ignore_errors=True)\\n parent_path = get_parent_path(path, ignore_errors=True)\\n logmsg = '[{0}] UNICODE WARNING {1}'.format(thread, os.path.join(parent_path, file_name))\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n \\n # index doc dict\\n data = {\\n 'name': file_name,\\n 'parent_path': parent_path,\\n 'size': size,\\n 'size_norecurs': size_norecurs,\\n 'size_du': size_du,\\n 'size_du_norecurs': size_du_norecurs,\\n 'file_count': files,\\n 'file_count_norecurs': files_norecurs, \\n 'dir_count': dirs + 1,\\n 'dir_count_norecurs': dirs_norecurs + 1,\\n 'dir_depth': depth,\\n 'mtime': datetime.utcfromtimestamp(int(d_stat.st_mtime)).isoformat(),\\n 'atime': datetime.utcfromtimestamp(int(d_stat.st_atime)).isoformat(),\\n 'ctime': datetime.utcfromtimestamp(int(d_stat.st_ctime)).isoformat(),\\n 'nlink': d_stat.st_nlink,\\n 'ino': str(d_stat.st_ino),\\n 'owner': owner,\\n 'group': group,\\n 'type': 'directory'\\n }\\n\\n # check if using altscanner and if any additional meta data to add to data dict\\n if options.altscanner:\\n try:\\n extrameta_dict = alt_scanner.add_meta(path, d_stat)\\n if extrameta_dict is not None:\\n data.update(extrameta_dict)\\n except Exception as e:\\n logmsg = '[{0}] ALT SCANNER EXCEPTION {1}'.format(thread, e)\\n logger.exception(logmsg)\\n if logtofile: logger_warn.exception(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n # check plugins for adding extra meta data to data dict\\n if plugins_enabled and plugins_dirs:\\n for plugin in plugins:\\n # check if plugin is for directory doc\\n try:\\n if plugin.for_type('directory'):\\n extrameta_dict = plugin.add_meta(path, d_stat)\\n if extrameta_dict is not None:\\n data.update(extrameta_dict)\\n except (RuntimeWarning, RuntimeError) as e:\\n err_message = e.args[0]\\n if e.__class__ == RuntimeWarning:\\n logmsg = '[{0}] PLUGIN WARNING: {1}'.format(thread, err_message)\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n else:\\n logmsg = '[{0}] PLUGIN ERROR: {1}'.format(thread, err_message)\\n logger.error(logmsg)\\n if logtofile: logger_warn.error(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n extrameta_dict = e.args[1]\\n if extrameta_dict is not None:\\n data.update(extrameta_dict)\\n except Exception as e:\\n logmsg = '[{0}] PLUGIN EXCEPTION: {1}'.format(thread, e)\\n logger.exception(logmsg)\\n if logtofile: logger_warn.exception(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n \\n if depth > 0:\\n # add file doc to docs list and upload to ES once it reaches certain size\\n docs.append(data.copy())\\n doc_count = len(docs)\\n if doc_count >= es_chunksize:\\n start_bulk_upload(thread, root, docs)\\n tot_doc_count += doc_count\\n docs.clear()\\n \\n else:\\n with crawl_thread_lock:\\n sizes[root] = data.copy()\\n else:\\n d_skip_count += 1\\n logger.debug('[{0}] skipping empty dir {1}'.format(thread, path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] skipping empty dir {1}'.format(thread, path))\\n if dirs > 0: dirs -= 1\\n\\n with crawl_thread_lock:\\n dircount[root] += d_count - d_skip_count\\n filecount[root] += f_count - f_skip_count\\n skipfilecount[root] += f_skip_count\\n skipdircount[root] += d_skip_count\\n total_doc_count[root] += tot_doc_count\\n inodecount[root] += d_count + f_count \\n\\n except OSError as e:\\n logmsg = '[{0}] OS ERROR: {1}'.format(thread, e)\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n except RuntimeError as e:\\n logmsg = '[{0}] ALT SCANNER ERROR: {1}'.format(thread, e)\\n logger.error(logmsg)\\n if logtofile: logger_warn.error(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n \\n return size, size_du, files, dirs\",\n \"def set_depth(self, d):\\r\\n self.depth = d\",\n \"def create(self):\\n\\n for sample_name, sample_info in self.samples.items():\\n if not sample_info[\\\"use_it\\\"] or sample_info[\\\"sample_category\\\"] in [ \\\"additional_signal_overlap\\\", \\\"background_data_estimate\\\" ]:\\n continue\\n process_name = sample_info[\\\"process_name_specific\\\"]\\n for charge_selection in self.charge_selections:\\n key_dir = getKey(process_name, charge_selection)\\n for dir_type in [ DKEY_CFGS, DKEY_HIST, DKEY_LOGS, DKEY_RLES ]:\\n initDict(self.dirs, [ key_dir, dir_type ])\\n if dir_type in [ DKEY_CFGS, DKEY_LOGS ]:\\n self.dirs[key_dir][dir_type] = os.path.join(self.configDir, dir_type, self.channel,\\n \\\"_\\\".join([ charge_selection ]), process_name)\\n else:\\n self.dirs[key_dir][dir_type] = os.path.join(self.outputDir, dir_type, self.channel,\\n \\\"_\\\".join([ charge_selection ]), process_name)\\n for dir_type in [ DKEY_CFGS, DKEY_SCRIPTS, DKEY_HIST, DKEY_LOGS, DKEY_DCRD, DKEY_PLOT, DKEY_HADD_RT ]:\\n initDict(self.dirs, [ dir_type ])\\n if dir_type in [ DKEY_CFGS, DKEY_SCRIPTS, DKEY_LOGS, DKEY_DCRD, DKEY_PLOT, DKEY_HADD_RT ]:\\n self.dirs[dir_type] = os.path.join(self.configDir, dir_type, self.channel)\\n else:\\n self.dirs[dir_type] = os.path.join(self.outputDir, dir_type, self.channel)\\n ##print \\\"self.dirs = \\\", self.dirs\\n\\n for key in self.dirs.keys():\\n if type(self.dirs[key]) == dict:\\n for dir_type in self.dirs[key].keys():\\n create_if_not_exists(self.dirs[key][dir_type])\\n else:\\n create_if_not_exists(self.dirs[key])\\n\\n inputFileLists = {}\\n for sample_name, sample_info in self.samples.items():\\n if not sample_info[\\\"use_it\\\"] or sample_info[\\\"sample_category\\\"] in [ \\\"additional_signal_overlap\\\", \\\"background_data_estimate\\\" ]:\\n continue\\n logging.info(\\\"Checking input files for sample %s\\\" % sample_info[\\\"process_name_specific\\\"])\\n inputFileLists[sample_name] = generateInputFileList(sample_name, sample_info, self.max_files_per_job, self.debug)\\n \\n self.inputFileIds = {}\\n for sample_name, sample_info in self.samples.items():\\n if not sample_info[\\\"use_it\\\"] or sample_info[\\\"sample_category\\\"] in [ \\\"additional_signal_overlap\\\", \\\"background_data_estimate\\\" ]:\\n continue\\n\\n process_name = sample_info[\\\"process_name_specific\\\"]\\n\\n logging.info(\\\"Creating configuration files to run '%s' for sample %s\\\" % (self.executable_analyze, process_name)) \\n\\n is_mc = (sample_info[\\\"type\\\"] == \\\"mc\\\")\\n lumi_scale = 1. if not (self.use_lumi and is_mc) else sample_info[\\\"xsection\\\"] * self.lumi / sample_info[\\\"nof_events\\\"]\\n apply_genWeight = sample_info[\\\"apply_genWeight\\\"] if (is_mc and \\\"apply_genWeight\\\" in sample_info.keys()) else False\\n sample_category = sample_info[\\\"sample_category\\\"]\\n triggers = sample_info[\\\"triggers\\\"]\\n apply_trigger_bits = (is_mc and (self.era == \\\"2015\\\" or (self.era == \\\"2016\\\" and sample_info[\\\"reHLT\\\"]))) or not is_mc\\n\\n for charge_selection in self.charge_selections:\\n for central_or_shift in self.central_or_shifts:\\n\\n inputFileList = inputFileLists[sample_name]\\n for jobId in inputFileList.keys():\\n if central_or_shift != \\\"central\\\" and not is_mc:\\n continue\\n if central_or_shift.startswith(\\\"CMS_ttHl_thu_shape_ttH\\\") and sample_category != \\\"signal\\\":\\n continue\\n if central_or_shift.startswith(\\\"CMS_ttHl_thu_shape_ttW\\\") and sample_category != \\\"TTW\\\":\\n continue\\n if central_or_shift.startswith(\\\"CMS_ttHl_thu_shape_ttZ\\\") and sample_category != \\\"TTZ\\\":\\n continue\\n\\n # build config files for executing analysis code\\n key_dir = getKey(process_name, charge_selection)\\n key_analyze_job = getKey(process_name, charge_selection, central_or_shift, jobId)\\n\\n ntupleFiles = inputFileList[jobId]\\n if len(ntupleFiles) == 0:\\n print \\\"Warning: ntupleFiles['%s'] = %s --> skipping job !!\\\" % (key_job, ntupleFiles)\\n continue\\n self.jobOptions_analyze[key_analyze_job] = {\\n 'ntupleFiles' : ntupleFiles,\\n 'cfgFile_modified' : os.path.join(self.dirs[key_dir][DKEY_CFGS], \\\"analyze_%s_%s_%s_%s_%i_cfg.py\\\" % \\\\\\n (self.channel, process_name, charge_selection, central_or_shift, jobId)),\\n 'histogramFile' : os.path.join(self.dirs[key_dir][DKEY_HIST], \\\"%s_%s_%s_%i.root\\\" % \\\\\\n (process_name, charge_selection, central_or_shift, jobId)),\\n 'logFile' : os.path.join(self.dirs[key_dir][DKEY_LOGS], \\\"analyze_%s_%s_%s_%s_%i.log\\\" % \\\\\\n (self.channel, process_name, charge_selection, central_or_shift, jobId)),\\n 'sample_category' : sample_category,\\n 'triggers' : sample_info[\\\"triggers\\\"],\\n 'charge_selection' : charge_selection,\\n 'jet_minPt' : self.jet_minPt,\\n 'jet_maxPt' : self.jet_maxPt,\\n 'jet_minAbsEta' : self.jet_minAbsEta,\\n 'jet_maxAbsEta' : self.jet_maxAbsEta,\\n 'hadTau_selection_denominator' : self.hadTau_selection_denominator,\\n 'hadTau_selections_numerator' : self.hadTau_selections_numerator,\\n 'absEtaBins' : self.absEtaBins,\\n ##'use_HIP_mitigation_mediumMuonId' : sample_info[\\\"use_HIP_mitigation_mediumMuonId\\\"],\\n 'use_HIP_mitigation_mediumMuonId' : True,\\n 'is_mc' : is_mc,\\n 'central_or_shift' : central_or_shift,\\n 'lumi_scale' : 1. if not (self.use_lumi and is_mc) else sample_info[\\\"xsection\\\"] * self.lumi / sample_info[\\\"nof_events\\\"],\\n 'apply_genWeight' : sample_info[\\\"genWeight\\\"] if (is_mc and \\\"genWeight\\\" in sample_info.keys()) else False,\\n 'apply_trigger_bits' : (is_mc and (self.era == \\\"2015\\\" or (self.era == \\\"2016\\\" and sample_info[\\\"reHLT\\\"]))) or not is_mc,\\n }\\n self.createCfg_analyze(self.jobOptions_analyze[key_analyze_job])\\n\\n # initialize input and output file names for hadd_stage1\\n key_hadd_stage1 = getKey(process_name, charge_selection)\\n if not key_hadd_stage1 in self.inputFiles_hadd_stage1:\\n self.inputFiles_hadd_stage1[key_hadd_stage1] = []\\n self.inputFiles_hadd_stage1[key_hadd_stage1].append(self.jobOptions_analyze[key_analyze_job]['histogramFile'])\\n self.outputFile_hadd_stage1[key_hadd_stage1] = os.path.join(self.dirs[DKEY_HIST], \\\"histograms_harvested_stage1_%s_%s_%s.root\\\" % \\\\\\n (self.channel, process_name, charge_selection))\\n\\n # initialize input and output file names for hadd_stage2\\n key_hadd_stage1 = getKey(process_name, charge_selection)\\n key_hadd_stage2 = getKey(charge_selection)\\n if not key_hadd_stage2 in self.inputFiles_hadd_stage2:\\n self.inputFiles_hadd_stage2[key_hadd_stage2] = []\\n self.inputFiles_hadd_stage2[key_hadd_stage2].append(self.outputFile_hadd_stage1[key_hadd_stage1])\\n self.outputFile_hadd_stage2[key_hadd_stage2] = os.path.join(self.dirs[DKEY_HIST], \\\"histograms_harvested_stage2_%s_%s.root\\\" % \\\\\\n (self.channel, charge_selection))\\n\\n logging.info(\\\"Creating configuration files for executing 'comp_jetToTauFakeRate'\\\")\\n for charge_selection in self.charge_selections:\\n key_comp_jetToTauFakeRate_job = getKey(charge_selection)\\n key_hadd_stage2 = getKey(charge_selection)\\n self.jobOptions_comp_jetToTauFakeRate[key_comp_jetToTauFakeRate_job] = {\\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2],\\n 'cfgFile_modified' : os.path.join(\\n self.dirs[DKEY_CFGS], \\\"comp_jetToTauFakeRate_%s_cfg.py\\\" % charge_selection),\\n 'outputFile' : os.path.join(\\n self.dirs[DKEY_HIST], \\\"comp_jetToTauFakeRate_%s.root\\\" % charge_selection),\\n 'logFile' : os.path.join(\\n self.dirs[DKEY_LOGS], \\\"comp_jetToTauFakeRate_%s.log\\\" % charge_selection),\\n 'looseRegion' : \\\"jetToTauFakeRate_%s/denominator/\\\" % charge_selection,\\n 'tightRegion' : \\\"jetToTauFakeRate_%s/numerator/\\\" % charge_selection,\\n 'absEtaBins' : self.absEtaBins,\\n 'ptBins' : self.ptBins\\n }\\n self.createCfg_comp_jetToTauFakeRate(self.jobOptions_comp_jetToTauFakeRate[key_comp_jetToTauFakeRate_job])\\n self.targets.append(self.jobOptions_comp_jetToTauFakeRate[key_comp_jetToTauFakeRate_job]['outputFile'])\\n\\n logging.info(\\\"Creating configuration files to run 'makePlots'\\\")\\n for charge_selection in self.charge_selections:\\n key_makePlots_job = getKey(charge_selection)\\n key_hadd_stage2 = getKey(charge_selection)\\n self.jobOptions_make_plots[key_makePlots_job] = {\\n 'executable' : self.executable_make_plots,\\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2],\\n 'cfgFile_modified' : os.path.join(\\n self.dirs[DKEY_CFGS], \\\"makePlots_%s_cfg.py\\\" % self.channel),\\n 'outputFile' : os.path.join(\\n self.dirs[DKEY_PLOT], \\\"makePlots_%s.png\\\" % self.channel),\\n 'histogramDir' : \\\"jetToTauFakeRate_%s\\\" % charge_selection,\\n 'label' : None,\\n 'make_plots_backgrounds' : [ \\\"TT\\\", \\\"TTW\\\", \\\"TTZ\\\", \\\"EWK\\\", \\\"Rares\\\" ],\\n }\\n self.createCfg_makePlots(self.jobOptions_make_plots[key_makePlots_job])\\n self.cfgFile_make_plots = self.cfgFile_make_plots_denominator\\n for absEtaBin in [ \\\"absEtaLt1_5\\\", \\\"absEta1_5to9_9\\\" ]:\\n key_makePlots_job = getKey(charge_selection, absEtaBin, \\\"denominator\\\")\\n key_hadd_stage2 = getKey(charge_selection)\\n self.jobOptions_make_plots[key_makePlots_job] = {\\n 'executable' : self.executable_make_plots,\\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2],\\n 'cfgFile_modified' : os.path.join(\\n self.dirs[DKEY_CFGS], \\\"makePlots_%s_%s_denominator_%s_cfg.py\\\" % (self.channel, charge_selection, absEtaBin)),\\n 'outputFile' : os.path.join(\\n self.dirs[DKEY_PLOT], \\\"makePlots_%s_%s_denominator_%s.png\\\" % (self.channel, charge_selection, absEtaBin)),\\n 'histogramDir' : \\\"jetToTauFakeRate_%s/denominator/%s\\\" % (charge_selection, absEtaBin),\\n 'label' : None,\\n 'make_plots_backgrounds' : [ \\\"TT\\\", \\\"TTW\\\", \\\"TTZ\\\", \\\"EWK\\\", \\\"Rares\\\" ],\\n }\\n self.createCfg_makePlots(self.jobOptions_make_plots[key_makePlots_job])\\n for hadTau_selection_numerator in self.hadTau_selections_numerator:\\n key_makePlots_job = getKey(charge_selection, absEtaBin, \\\"numerator\\\", hadTau_selection_numerator)\\n key_hadd_stage2 = getKey(charge_selection)\\n self.jobOptions_make_plots[key_makePlots_job] = {\\n 'executable' : self.executable_make_plots,\\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2],\\n 'cfgFile_modified' : os.path.join(\\n self.dirs[DKEY_CFGS], \\\"makePlots_%s_%s_numerator_%s_%s_cfg.py\\\" % (self.channel, charge_selection, hadTau_selection_numerator, absEtaBin)),\\n 'outputFile' : os.path.join(\\n self.dirs[DKEY_PLOT], \\\"makePlots_%s_%s_numerator_%s_%s.png\\\" % (self.channel, charge_selection, hadTau_selection_numerator, absEtaBin)),\\n 'histogramDir' : \\\"jetToTauFakeRate_%s/numerator/%s/%s\\\" % (charge_selection, hadTau_selection_numerator, absEtaBin),\\n 'label' : None,\\n 'make_plots_backgrounds' : [ \\\"TT\\\", \\\"TTW\\\", \\\"TTZ\\\", \\\"EWK\\\", \\\"Rares\\\" ],\\n }\\n self.createCfg_makePlots(self.jobOptions_make_plots[key_makePlots_job])\\n\\n if self.is_sbatch:\\n logging.info(\\\"Creating script for submitting '%s' jobs to batch system\\\" % self.executable_analyze)\\n self.sbatchFile_analyze = os.path.join(self.dirs[DKEY_SCRIPTS], \\\"sbatch_analyze_%s.py\\\" % self.channel)\\n self.createScript_sbatch_analyze(self.executable_analyze, self.sbatchFile_analyze, self.jobOptions_analyze)\\n logging.info(\\\"Creating script for submitting '%s' jobs to batch system\\\" % self.executable_comp_jetToTauFakeRate)\\n self.sbatchFile_comp_jetToTauFakeRate = os.path.join(self.dirs[DKEY_SCRIPTS], \\\"sbatch_comp_jetToTauFakeRate.py\\\")\\n self.createScript_sbatch(self.executable_comp_jetToTauFakeRate, self.sbatchFile_comp_jetToTauFakeRate, self.jobOptions_comp_jetToTauFakeRate)\\n\\n lines_makefile = []\\n self.addToMakefile_analyze(lines_makefile)\\n self.addToMakefile_hadd_stage1(lines_makefile)\\n self.addToMakefile_hadd_stage2(lines_makefile)\\n self.addToMakefile_comp_jetToTauFakeRate(lines_makefile)\\n self.addToMakefile_make_plots(lines_makefile)\\n self.createMakefile(lines_makefile)\\n \\n logging.info(\\\"Done\\\")\",\n \"def __get_max_depth(self, conf):\\n return conf[self.conf_item.get_max_depth()]\",\n \"def __init__(self, shouldPack = True):\\n self.name = datatypes.String(\\\"\\\")\\n self.rva = datatypes.DWORD(0) #: L{DWORD} rva.\\n self.size = datatypes.DWORD(0) #: L{DWORD} size.\\n self.info = None #: This variable holds the information of the directory.\\n self.shouldPack = shouldPack\",\n \"def size(**kwargs):\\n mpath = kwargs['path']\\n if not os.path.exists(mpath):\\n print(\\\"Invalid path\\\")\\n sys.exit(-1)\\n\\n # Basic Counter variables\\n foldercount = 0\\n count = 0\\n\\n # List containing the collected information\\n elist = []\\n\\n # Indices for the 2 dimensional list\\n iext = 0\\n icount = 1\\n icsums = 2\\n imins = 3\\n imaxs = 4\\n\\n start_depth = len(mpath.split('/')) - 2\\n depth = 0\\n\\n for root, dirs, files in os.walk(mpath, topdown=True):\\n\\n indircount = 0\\n for name in files:\\n pathfile = os.path.join(root, name)\\n indircount += 1\\n # Extension\\n ext = (os.path.splitext(name)[1]).lower()[1:]\\n if ext == '': ext = 'no ext'\\n # Size\\n size = os.stat(pathfile).st_size\\n\\n # Folder depth\\n cdepth = len(os.path.abspath(pathfile).split('/')) - start_depth\\n if depth < cdepth: depth = cdepth\\n\\n # Getting the index of the current file extension using python built-in functions\\n try:\\n index = list(zip(*elist))[iext].index(ext)\\n except IndexError:\\n # The list is empty\\n index = -1\\n except ValueError:\\n # The list doesn't contain the extension\\n index = -1\\n\\n if index >= 0:\\n elist[index][icount] += 1\\n elist[index][icsums] += size\\n if size < elist[index][imins]: elist[index][imins] = size\\n if size > elist[index][imaxs]: elist[index][imaxs] = size\\n\\n else: # Adding the new extension in the list\\n elist.append([ext, 1, size, size, size])\\n count += indircount\\n\\n # Updating the directory count\\n for name in dirs:\\n foldercount += 1\\n\\n # Mapping arguments with indices in the list\\n dict = {\\n 'ext': iext,\\n 'count': icount,\\n 'size': icsums\\n }\\n\\n # Sorting the list\\n elist.sort(key=lambda x: x[dict.get(kwargs['sort'])], reverse=not kwargs['asc'])\\n\\n print(\\\"%d files in %d folders max depth: %s\\\\n\\\" % (count, foldercount, depth))\\n if kwargs['human']:\\n print(f\\\"{'Ext.':<8}{'Count':<13}{'Total':<10}{'Min':<11}{'Max':<13}{'Avg':<9}\\\")\\n for l in elist:\\n print(f\\\"{l[iext]:<7} {l[icount]:<12,d} {sizeformat(l[icsums]):<9} {sizeformat(l[imins]):<10} \\\\\\n{sizeformat(l[imaxs]):<12} {sizeformat(l[icsums] / l[icount]):<9}\\\")\\n else:\\n print(f\\\"{'Ext.':<8}{'Count':<13}{'Total':<13}{'Min':<13}{'Max':<13}{'Avg':<2}\\\")\\n for l in elist:\\n print(f\\\"{l[iext]:<7} {l[icount]:<12,d} {l[icsums]:<12} {l[imins]:<12} {l[imaxs]:<12} \\\\\\n{int(round(l[icsums] / l[icount], 0)):<12}\\\")\",\n \"def update_list(self):\\n\\t\\ttry:\\n\\t\\t\\tassert(not self.master.TransactionInProgress)\\n\\t\\t\\tself.master.Vacuum()\\n\\n\\t\\t\\tself.fetch_repo_file(\\\"/torrent\\\", self.config[\\\"daemon\\\"][\\\"rootdir\\\"] + \\\"/torrent\\\", \\\"wb\\\")\\n\\t\\t\\tself.master.master = json.loads(self.fetch_repo_file(\\\"/package-index.json\\\", True).decode('utf-8'))\\n\\t\\t\\tself.torrent_info = lt.torrent_info(self.config[\\\"daemon\\\"][\\\"rootdir\\\"] + \\\"/torrent\\\")\\n\\n\\t\\t\\t\\\"\\\"\\\" Find pre-downloaded files \\\"\\\"\\\"\\n\\t\\t\\tpre_downloaded = {}\\n\\t\\t\\ti = 0\\n\\t\\t\\tfor f in self.torrent_info.files():\\n\\t\\t\\t\\tif self.valid_tpkg_file(f.path):\\n\\t\\t\\t\\t\\tpre_downloaded[i] = f\\n\\t\\t\\t\\ti += 1\\n\\n\\n\\t\\t\\t\\\"\\\"\\\" Default torrent params \\\"\\\"\\\"\\n\\t\\t\\tparams = {\\n\\t\\t\\t\\t\\\"save_path\\\": self.config[\\\"daemon\\\"][\\\"rootdir\\\"],\\n\\t\\t\\t\\t\\\"ti\\\": self.torrent_info\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t\\t\\\"\\\"\\\" Set torrent handler \\\"\\\"\\\"\\n\\t\\t\\tself.handler = self.ses.add_torrent(params)\\n\\n\\t\\t\\t\\\"\\\"\\\" Set chunk priority to 0 (don't download) \\\"\\\"\\\"\\n\\t\\t\\tfor p in range(self.torrent_info.num_pieces()):\\n\\t\\t\\t\\tself.handler.piece_priority(p, 0)\\n\\n\\t\\t\\tfor i in self.torrent_info.files():\\n\\t\\t\\t\\tif i in pre_downloaded:\\n\\t\\t\\t\\t\\tpr = self.torrent_info.map_file(i, 0, pre_downloaded[i].size)\\n\\t\\t\\t\\t\\tn_pieces = pr.length / self.torrent_info.piece_length() + 1\\n\\n\\t\\t\\t\\t\\tfor p in range(self.torrent_info.num_pieces()):\\n\\t\\t\\t\\t\\t\\tif p in range(pr.piece, pr.piece + n_pieces):\\n\\t\\t\\t\\t\\t\\t\\tself.handler.piece_priority(p, 7)\\n\\n\\t\\texcept Exception as e:\\n\\t\\t\\tsys.stderr.write(\\\"Failed to update package list: {0}\\\\n\\\".format(e))\\n\\t\\t\\ttraceback.print_exc()\\n\\t\\t\\tself.write_line(\\\"Error: XXX - Failed to update package list.\\\")\",\n \"def anneal(self,anPackages=None,progress=None):\\n data = self.data\\n data_sizeCrcDate = self.data_sizeCrcDate\\n anPackages = set(anPackages or data)\\n getArchiveOrder = lambda x: data[x].order\\n #--Get remove/refresh files from anPackages\\n removes = set()\\n for package in anPackages:\\n installer = data[package]\\n removes |= installer.underrides\\n if installer.isActive:\\n removes |= installer.missingFiles\\n removes |= set(installer.dirty_sizeCrc)\\n #--March through packages in reverse order...\\n restores = {}\\n for package in sorted(data,key=getArchiveOrder,reverse=True):\\n installer = data[package]\\n #--Other active package. May provide a restore file.\\n # And/or may block later uninstalls.\\n if installer.isActive:\\n files = set(installer.data_sizeCrc)\\n myRestores = (removes & files) - set(restores)\\n for file in myRestores:\\n if installer.data_sizeCrc[file] != data_sizeCrcDate.get(file,(0,0,0))[:2]:\\n restores[file] = package\\n removes.discard(file)\\n #--Remove files\\n emptyDirs = set()\\n modsDir = dirs['mods']\\n for file in removes:\\n path = modsDir.join(file)\\n path.remove()\\n (path+'.ghost').remove()\\n data_sizeCrcDate.pop(file,None)\\n emptyDirs.add(path.head)\\n #--Remove empties\\n for emptyDir in emptyDirs:\\n if emptyDir.isdir() and not emptyDir.list():\\n emptyDir.removedirs()\\n #--Restore files\\n restoreArchives = sorted(set(restores.itervalues()),key=getArchiveOrder,reverse=True)\\n if restoreArchives: \\n progress.setFull(len(restoreArchives))\\n for index,package in enumerate(restoreArchives):\\n progress(index,package.s)\\n installer = data[package]\\n destFiles = set(x for x,y in restores.iteritems() if y == package)\\n if destFiles:\\n installer.install(package,destFiles,data_sizeCrcDate,\\n SubProgress(progress,index,index+1))\",\n \"def setFullCompression(self,value):\\n self.PDFreactorConfiguration.in1[\\\"fullCompression\\\"] = value\",\n \"def _create_package_dir(self):\\n\\n recursive = True if self.format == 'src' else False\\n return self.create_dir(self.packageDir, recursive=recursive)\",\n \"def bit_depth(self, value):\\n self._bit_depth = value\\n self._max_DN = (2 ** self.bit_depth) - 1\",\n \"def bit_depth(self, value):\\n self._bit_depth = value\\n self._max_DN = (2 ** self.bit_depth) - 1\",\n \"def __create_dir_structure_file__(self):\\n # | - __create_dir_structure_file__\\n\\n dir_structure_data = {}\\n dir_structure_data[\\\"tree_level_labels\\\"] = self.tree_level_labels\\n dir_structure_data[\\\"level_entries_dict\\\"] = self.level_entries_list\\n # TEMP\\n dir_structure_data[\\\"skip_dirs\\\"] = self.skip_dirs_lst\\n\\n fle_name = os.path.join(\\n self.root_dir,\\n self.working_dir,\\n \\\"jobs_bin/dir_structure.json\\\",\\n )\\n\\n with open(fle_name, \\\"w\\\") as fle:\\n json.dump(dir_structure_data, fle, indent=2)\\n # __|\",\n \"def packDir(self, path='', recursive=True, autorotate=False, debug=False):\\n\\n Console.info('Packing sprites in: %s' % os.path.join(self.base, path))\\n Console.indent()\\n \\n self.files = []\\n self.addDir(path, recursive=recursive)\\n Console.info('Found %d images' % len(self.files))\\n\\n if len(self.files) > 0:\\n self.generate(path, autorotate, debug)\\n \\n Console.outdent()\",\n \"def pass1(self, verbose):\\n \\n for root, dirs, files in os.walk(self.dir_to_check, topdown=False):\\n t_size = 0\\n for f in files:\\n new_f = os.path.join(root,f) #complete path in case of homonyms\\n size = os.path.getsize(new_f)\\n t_size += size\\n self.cache[new_f] = HumanReadableSize(size)\\n t_size += sum ([self.cache[os.path.join(root,d)].val for d in dirs])\\n self.cache[root] = HumanReadableSize(t_size)\\n if verbose:\\n print ('.................... Computing size of {}!'.format(root))\\n \\n #print (self.cache) #debugging\",\n \"def adjust_data_directory_size(self):\\n for entry in self.PE.OPTIONAL_HEADER.DATA_DIRECTORY:\\n if entry.name == 'IMAGE_DIRECTORY_ENTRY_IMPORT':\\n # TODO : modify this.\\n entry.Size += (self.count_of_additional_dll * 20)\\n elif entry.name == 'IMAGE_DIRECTORY_ENTRY_IAT':\\n entry.Size += (self.count_of_additional_fn * 4)\",\n \"def test_build_children_state_default_extra(self):\\n l_a = SystemFile(\\\"a\\\", 150, True)\\n l_aa = SystemFile(\\\"aa\\\", 50, True)\\n l_a.add_child(l_aa)\\n l_aaa = SystemFile(\\\"aaa\\\", 50, False)\\n l_aa.add_child(l_aaa)\\n l_ab = SystemFile(\\\"ab\\\", 100, False)\\n l_a.add_child(l_ab)\\n\\n self.model_builder.set_local_files([l_a])\\n model = self.model_builder.build_model()\\n m_a = model.get_file(\\\"a\\\")\\n self.assertEqual(ModelFile.State.DEFAULT, m_a.state)\\n m_a_ch = {m.name: m for m in model.get_file(\\\"a\\\").get_children()}\\n m_aa = m_a_ch[\\\"aa\\\"]\\n self.assertEqual(ModelFile.State.DEFAULT, m_aa.state)\\n m_aaa = m_aa.get_children()[0]\\n self.assertEqual(ModelFile.State.DEFAULT, m_aaa.state)\\n m_ab = m_a_ch[\\\"ab\\\"]\\n self.assertEqual(ModelFile.State.DEFAULT, m_ab.state)\",\n \"def _set_max_open_files(command, key):\\n global _MAX_OPEN_FILES\\n if _MAX_OPEN_FILES is None:\\n _MAX_OPEN_FILES = (paleomix.common.system.get_max_open_files(),)\\n\\n (max_open_files,) = _MAX_OPEN_FILES\\n if max_open_files:\\n max_open_files = int(max_open_files * _FRAC_MAX_OPEN_FILES)\\n\\n if max_open_files < _DEFAULT_MAX_OPEN_FILES:\\n command.append(key, max_open_files)\",\n \"def assign_defaults(self):\\n\\n def module_default_sort_key(module):\\n sort_key = (\\n 1 if module.marked_as_default else -1,\\n module.version,\\n module.variant,\\n -self.index(module.modulepath),\\n )\\n return sort_key\\n\\n self.defaults = {}\\n grouped = groupby(\\n [module for path in self.path for module in path.modules], lambda x: x.name\\n )\\n for (_, modules) in grouped:\\n for module in modules:\\n module.is_default = False\\n if len(modules) > 1:\\n modules = sorted(modules, key=module_default_sort_key, reverse=True)\\n modules[0].is_default = True\\n self.defaults[modules[0].name] = modules[0]\",\n \"def min_detection_strategy(self, init_model_infos):\\n model_folder = 'min_detection_model_v2'\\n result = self.detection(init_model_infos)\\n # here add some methods to make select more 'clever'\\n rank_hard_images = sorted(result.items(), key=lambda item:item[1], reverse=True)\\n total_amount = 30\\n trained_images = []\\n # Select most hard images (30 as a step)\\n # Start training with select images\\n while total_amount < 150:\\n al_model = TrainingProcess()\\n al_model_data = []\\n \\\"\\\"\\\"\\n # CEAL to get better result pick 15 most hard and 15 most easy\\n for item in rank_hard_images[:20]:\\n al_model_data.append(item[0])\\n trained_images.append(item[0])\\n for item in rank_hard_images[-10:]:\\n al_model_data.append(item[0])\\n trained_images.append(item[0])\\n print('select images are:', al_model_data)\\n \\\"\\\"\\\"\\n # To keep the distribution same, take the package that have the most hard images for training\\n package_distrib = [0] * 11\\n for item in rank_hard_images[:30]:\\n package_distrib[(int(item[0].split('.')[0]) -1) // 30] += 1\\n package_id = package_distrib.index(max(package_distrib))\\n image_to_package_dir = os.path.join(DATA_DIR, \\\"package%s\\\" % package_id)\\n al_model_data = os.listdir(image_to_package_dir)\\n print('select package are:', package_id)\\n print('select images are:', al_model_data)\\n total_amount += 30\\n if total_amount == 60:\\n last_model_info = init_model_infos\\n else:\\n last_model_info = al_model_info\\n last_model_path = os.path.join(last_model_info[0], last_model_info[1] + '.h5')\\n last_model_weights = os.path.join(MODEL_DIR, last_model_path)\\n al_model_info = [model_folder, '%s_images_model' % total_amount]\\n al_model.train_model(al_model_data, al_model_info, self.dataset_val, cur_model_path=last_model_weights)\\n al_model.mAP_of_model(al_model_info, self.dataset_val)\\n result = self.detection(al_model_info, trained_images)\\n rank_hard_images = sorted(result.items(), key=lambda item:item[1], reverse=True)\\n del al_model\\n print(\\\"Ending selection\\\")\",\n \"def traverse(self, filelist, depth=0):\\n if depth > 10:\\n return ['depth > 10']\\n level = {}\\n for entry in (path for path in self.connection.nlst() if path not in ('.', '..')):\\n try:\\n self.connection.cwd(entry)\\n level[entry] = self.traverse(filelist, depth+1)\\n self.connection.cwd('..')\\n except ftplib.error_perm:\\n level[entry] = None\\n return level\",\n \"def __load_dir_structure_file__(self):\\n # | - __load_dir_structure_file__\\n try:\\n try:\\n fle_name = self.root_dir + \\\"/jobs_bin/dir_structure.json\\\"\\n\\n with open(fle_name, \\\"r\\\") as dir_struct_f:\\n data = json.load(dir_struct_f)\\n\\n tree_level = data[\\\"tree_level_labels\\\"]\\n level_entries = data[\\\"level_entries_dict\\\"]\\n\\n if \\\"skip_dirs\\\" in data.keys():\\n skip_dirs_lst = data[\\\"skip_dirs\\\"]\\n self.skip_dirs_lst = skip_dirs_lst\\n\\n self.tree_level_labels = tree_level\\n self.level_entries = level_entries\\n self.level_entries_list = level_entries\\n\\n except:\\n print(\\\"Couldn't read /jobs_bin/dir_structure.json\\\")\\n\\n try:\\n\\n # | - __old__\\n tmp = 42\\n # print(\\\"old - Reading dir_structure.json file \\\\\\n # from root_dir\\\")\\n #\\n # fle_name = self.root_dir + \\\"/dir_structure.json\\\"\\n # with open(fle_name, \\\"r\\\") as dir_struct_f:\\n # data = json.load(dir_struct_f)\\n # tree_level = data[\\\"tree_level_labels\\\"]\\n # level_entries = data[\\\"level_entries_dict\\\"]\\n #\\n # if \\\"skip_dirs\\\" in data.keys():\\n # skip_dirs_lst = data[\\\"skip_dirs\\\"]\\n # self.skip_dirs_lst = skip_dirs_lst\\n #\\n # self.tree_level_labels = tree_level\\n # self.level_entries = level_entries\\n # __|\\n\\n except:\\n print(\\\"Couldn't read /dir_structure.json\\\")\\n\\n pass\\n\\n except:\\n mess = \\\"Error opening 'dir_structure.json' file\\\"\\n raise IOError(mess)\\n\\n # __|\",\n \"def __init__(self, d=1):\\r\\n self.depth = d\",\n \"def custom_package_xml_generator(directory, packagename=None, version='45.0', filename='package.xml'):\\n\\n METADATA_TYPE = {\\n 'applications':'CustomApplication', 'aura':'AuraDefinitionBundle', 'classes':'ApexClass', 'customPermissions':'CustomPermission', \\n 'flexipages':'FlexiPage', 'flows':'Flow', 'globalValueSets':'GlobalValueSet', 'labels':'CustomLabels', 'layouts':'Layout',\\n 'lwc': 'LightningComponentBundle', 'objects':'CustomObject', 'pages':'ApexPage', 'permissionsets':'PermissionSet', 'profiles':'Profile',\\n 'staticresources':'StaticResource', 'tabs':'CustomTab', 'triggers':'ApexTrigger', 'contentassets':'ContentAsset', 'pathAssistants':'PathAssistant',\\n 'quickActions':'QuickAction', 'remoteSiteSettings':'RemoteSiteSetting', 'workflows':'Workflow', 'dashboards':'Dashboard', 'reports':'Report',\\n 'cspTrustedSites':'CspTrustedSite',\\n }\\n\\n \\\"\\\"\\\"\\n Non-implemented Metadata:\\n 'ApexComponent', 'CustomMetadata' (needs custom manipulation), 'CustomObjectTranslation', 'DuplicateRule', \\n 'FlowCategory', 'GlobalValueSetTranslation', 'MatchingRules',\\n \\\"\\\"\\\"\\n #read directory structure\\n\\n mdtypedirs = os.listdir(directory)\\n\\n nested_mdt_object = ['ValidationRule', 'CompactLayout', 'ListView', 'SharingReason', 'RecordType']\\n nested_mdt_workflow = ['WorkflowFieldUpdate', 'WorkflowKnowledgePublish', 'WorkflowTask', 'WorkflowAlert', 'WorkflowSend', 'WorkflowOutboundMessage', 'WorkflowRule']\\n\\n # start our xml structure\\n root = xml.Element('Package')\\n root.set('xmlns','http://soap.sforce.com/2006/04/metadata')\\n\\n for mdtype in mdtypedirs:\\n # create child node for each type of component\\n if mdtype in METADATA_TYPE.keys():\\n etype = xml.SubElement(root, 'types')\\n ename = xml.SubElement(etype, 'name')\\n ename.text = str(METADATA_TYPE[mdtype])\\n emember = xml.SubElement(etype, 'members')\\n emember.text = str('*')\\n \\n if mdtype == 'objects':\\n for nest_mdtyp in nested_mdt_object:\\n etype = xml.SubElement(root, 'types')\\n ename = xml.SubElement(etype, 'name')\\n ename.text = nest_mdtyp\\n emember = xml.SubElement(etype, 'members')\\n emember.text = str('*')\\n\\n if mdtype == 'workflows':\\n for nest_mdtyp in nested_mdt_workflow:\\n etype = xml.SubElement(root, 'types')\\n ename = xml.SubElement(etype, 'name')\\n ename.text = nest_mdtyp\\n emember = xml.SubElement(etype, 'members')\\n emember.text = str('*')\\n\\n #Custom behavior for custom labels\\n if mdtype == 'labels':\\n etype = xml.SubElement(root, 'types')\\n ename = xml.SubElement(etype, 'name')\\n ename.text = 'CustomLabel'\\n emember = xml.SubElement(etype, 'members')\\n emember.text = str('*')\\n\\n # add the final xml node package.api_version\\n eversion = xml.SubElement(root, 'version')\\n eversion.text = str(version)\\n\\n #package name\\n if packagename != None:\\n efname = xml.SubElement(root, 'fullName')\\n efname.text = str(packagename)\\n\\n #pretty format for xml\\n xmlstring = xml.tostring(root)\\n reparsed = minidom.parseString(xmlstring)\\n prettyxml = reparsed.toprettyxml(indent=' ', newl='\\\\n', encoding='UTF-8')\\n \\n #generate xml file from string\\n try:\\n with open(os.path.join(directory, filename), \\\"bw\\\") as xml_file:\\n xml_file.write(prettyxml)\\n except IOError:\\n pass\",\n \"def set_depth(self):\\n if self.depth != None:\\n return\\n if not self.parents:\\n self.depth = 0\\n return\\n for parent in self.parents:\\n parent.set_depth()\\n \\n depths = [parent.depth for parent in self.parents]\\n self.depth = max(depths) + 1\",\n \"def depth(self, new_depth):\\n \\n # Check a type of 'new_depth' parametr \\n if not isinstance(new_depth, (int, long)):\\n raise TypeError('int or long type expected')\\n self._depth = new_depth\",\n \"def group_by_filenames(self):\\n package = self.container.config.output.package\\n class_map = collections.group_by(self.container, key=get_location)\\n groups = self.group_common_paths(class_map.keys())\\n\\n for keys in groups:\\n if len(keys) == 1:\\n common_path = os.path.dirname(keys[0])\\n else:\\n common_path = os.path.commonpath(keys)\\n\\n for key in keys:\\n items = class_map[key]\\n suffix = \\\".\\\".join(Path(key).parent.relative_to(common_path).parts)\\n\\n package_name = f\\\"{package}.{suffix}\\\" if suffix else package\\n self.assign(items, package_name, module_name(key))\",\n \"def _max_depth(self):\\n max_depth = 0\\n for node, data in self.traverse():\\n max_depth = max(max_depth, data['level'])\\n return max_depth\",\n \"def _analyze(self):\\n for _, self.subdirs, files in os.walk(self.path):\\n if self.p.sort:\\n self.subdirs.sort()\\n files.sort()\\n for f in files:\\n self._analyze_file(fileextlow(f), f)\\n break # stop walk() from entering subdirectories\\n\\n self.p.nr_dirs += 1\\n if self.lossless or self.compressed or self.videos:\\n if self.lossless or self.compressed:\\n if not self.images:\\n if self.p.warn_covers:\\n print(f\\\"{W}{self.path}{R}: no cover file\\\")\\n self.p.nr_no_cover += 1\\n elif not have_valid_cover_name(self.images):\\n if self.p.warn_covers:\\n print(f\\\"{W}{self.path}{R}: wrong cover names\\\")\\n self.p.nr_wrong_cover_name += 1\\n if self.lossless:\\n if self.compressed:\\n self.p.nr_mixed_lossless_compressed += 1\\n else:\\n self.p.nr_lossless_dirs += 1\\n\\n if self.cue:\\n if not self.lossless:\\n if self.p.warn_cue:\\n print(f\\\"{W}{self.path}{R}: cue but no lossless files\\\")\\n self.p.nr_lossy_cue += 1\\n elif not self.compressed:\\n if len(self.cue) == 1:\\n self.p.nr_cue += 1\\n else:\\n if self.p.warn_cue:\\n print(f\\\"{W}{self.path}{R}: {len(self.cue)} cue files\\\")\\n self.p.nr_multiple_cue += 1\\n\\n self.p.nr_media_dirs += 1\\n self.p.nr_lossless += len(self.lossless)\\n self.p.nr_compressed += len(self.compressed)\\n self.p.nr_video_files += len(self.videos)\\n self.p.nr_ignored += self.ignored\\n self.p.unknown.update(self.unknown)\\n else:\\n if self.images and not self.subdirs:\\n self.p.nr_only_images += 1\\n else:\\n self.p.nr_no_media_dirs += 1\",\n \"def find_files(root):\\n\\t\\n\\tdirs = []\\n\\ttry:\\n\\t\\tdirs += [ os.path.join(root, f) for f in os.listdir(root) ]\\n\\texcept OSError:\\n \\t\\ttry :\\n\\t\\t\\tfiles.append((os.path.getsize(root), root))\\n\\t\\texcept OSError:\\n\\t\\t\\tpass\\n\\n\\tfor Dir in dirs :\\n\\t\\tfind_files(Dir)\\n\\ndef get_top_N(root,n):\\n\\t\\n\\t\\\"\\\"\\\"\\n\\tReturns top n files based on their sizes\\n\\t\\\"\\\"\\\"\\n\\n\\tglobal files\\n\\tfind_files(root)\\n\\theapq.heapify(files)\\n\\tret = heapq.nlargest(n,files)\\n\\tfiles = []\\n\\treturn ret\\n\\ndef get_files_with_extensions(root):\\n\\t\\n\\t\\\"\\\"\\\"\\n\\tGets a dictionary of extension : [file]\\n\\t\\\"\\\"\\\"\\n\\t\\n\\tfind_files(root)\\n\\tglobal files\\n\\tfor filesize,filepath in files:\\n\\t\\tfilename, file_extension = os.path.splitext(filepath)\\n\\t\\t\\n\\t\\tfilename = filename.replace(' ','\\\\ ')\\n\\t\\tfilepath = filepath.replace(' ','\\\\ ')\\n\\n\\t\\tif file_extension == '' :\\n\\t\\t\\tfile_extension = '.EMPTY'\\n\\t\\tif file_extension not in ext_dict :\\n\\t\\t\\text_dict[file_extension] = []\\n\\t\\t\\n\\t\\text_dict[file_extension].append(filepath)\\n\\ndef make_directory(path,dirname):\\n\\t\\n\\t\\\"\\\"\\\"\\n\\tMakes a directory given path and directory name\\n\\t\\\"\\\"\\\"\\n\\n\\tdirectory_path = path + '/' + dirname\\n\\tcommand = 'mkdir ' + directory_path\\n\\t\\n\\ttry :\\n\\t\\tst = commands.getstatusoutput(command)\\n\\texcept Exception:\\n\\t\\traise\\n\\ndef movefile(destpath,filename,sourcepath):\\n\\t\\n\\t\\\"\\\"\\\"\\n\\tMoves a file to the destination path\\n\\t\\\"\\\"\\\"\\n\\n\\tcommand = 'mv ' + filename + ' ' + destpath\\n\\t\\n\\ttry :\\n\\t\\tst = commands.getstatusoutput(command)\\n\\texcept Exception:\\n\\t\\traise\\n\\ndef arrange_desktop_files(documentspath,desktoppath):\\n\\t\\n\\t\\\"\\\"\\\"\\n\\tCleans up the desktop by moving files into respective subfolders\\n\\tin the documents folder based on their extension.\\n\\tIgnore '.desktop' files extensions as they are shortcut files.\\n\\tFiles with no extensions are moved into EMPTY folder.\\n\\t\\\"\\\"\\\"\\n\\n\\tprint \\\"\\\\n\\\\n------------------Arranging Your Desktop-------------------\\\\n\\\\n\\\"\\n\\n\\tfor ext in ext_dict :\\n\\t\\tif ext != 'desktop':\\n\\t\\t\\tmake_directory(documentspath,ext[1:].upper())\\n\\t\\t\\tfor file in ext_dict[ext]:\\n\\t\\t\\t\\tprint file , \\\"----------------------->\\\" , documentspath+'/'+ext[1:] , '\\\\n'\\n\\t\\t\\t\\tmovefile(documentspath+'/'+ext[1:].upper(),file,desktoppath)\\n\\n\\n\\ndef printfiles(Files):\\n\\tprint \\\"\\\\n\\\\n------------------Largest 10 Files in your home directory-------------------\\\\n\\\\n\\\"\\n\\tfor filesize,file in Files :\\n\\t\\tprint file , filesize\\n\\n\\tprint \\\"\\\\n\\\\n\\\"\\n\\nif __name__ == \\\"__main__\\\":\\n\\t\\n\\t#Getting current user name\\n\\tcurrent_user = commands.getstatusoutput('whoami')[1]\\n\\t\\n\\t#Generating paths to various directories\\n\\tdesktop_path = '/home/' + current_user + '/Desktop'\\n\\tdocuments_path = '/home/' + current_user + '/Documents'\\n\\t\\n\\ttry :\\n\\t\\thome_path = sys.argv[1]\\n\\texcept Exception:\\n\\t\\thome_path = '/home'\\n\\n\\t#Getting top 10 files in our home directory\\n\\tprintfiles(get_top_N('/',10))\\n\\n\\t# Arranging desktop files into documents folder according to extensions\\n\\tget_files_with_extensions(desktop_path)\\n\\tarrange_desktop_files(documents_path , desktop_path)\",\n \"def apply(self,progress=None): \\n if progress:\\n self.progress = progress\\n self.cumSize = 0\\n self.totSize = 0\\n self.doRoot(self.sizeDir)\\n self.progress.setMax(self.totSize)\\n self.doRoot(self.applyDir)\\n settings.getChanged('mosh.resourceReplacer.applied').append(self.file)\\n self.progress = None\",\n \"def test_build_children_state_default(self):\\n r_a = SystemFile(\\\"a\\\", 300, True)\\n r_aa = SystemFile(\\\"aa\\\", 100, True)\\n r_a.add_child(r_aa)\\n r_aaa = SystemFile(\\\"aaa\\\", 100, False)\\n r_aa.add_child(r_aaa)\\n r_ab = SystemFile(\\\"ab\\\", 200, False)\\n r_a.add_child(r_ab)\\n\\n self.model_builder.set_remote_files([r_a])\\n model = self.model_builder.build_model()\\n m_a = model.get_file(\\\"a\\\")\\n self.assertEqual(ModelFile.State.DEFAULT, m_a.state)\\n m_a_ch = {m.name: m for m in model.get_file(\\\"a\\\").get_children()}\\n m_aa = m_a_ch[\\\"aa\\\"]\\n self.assertEqual(ModelFile.State.DEFAULT, m_aa.state)\\n m_aaa = m_aa.get_children()[0]\\n self.assertEqual(ModelFile.State.DEFAULT, m_aaa.state)\\n m_ab = m_a_ch[\\\"ab\\\"]\\n self.assertEqual(ModelFile.State.DEFAULT, m_ab.state)\",\n \"def packFiles(source, filesPerBlock, dest):\\n\\tfileCount = 1\\n\\t\\n\\ttmpFileName = \\\"tmp.h5\\\"\\t\\n\\n\\n\\toutFile = createBlockFile(tmpFileName)\\t\\n\\tfor dirname, subdirs, files in os.walk(source):\\t\\n\\t print 'Scanning ' + dirname + '...'\\t\\n\\t for f in files:\\t\\n\\t if f.endswith('.h5'):\\t\\n\\t inFile = h5py.File(os.path.join(dirname, f), 'r')\\t\\n\\t outFile.copy(inFile, outFile['songs'], f)\\t\\n\\t inFile.close()\\t\\n\\t fileCount = fileCount + 1\\t\\n\\t if(fileCount > filesPerBlock):\\t\\n\\t outFile.close()\\t\\n\\t upload(tmpFileName, bucket)\\t\\n\\t fileCount = 1\\t\\n\\t outFile = createBlockFile(tmpFileName)\\t\\n\\n \\toutFile.close()\\n \\tif fileCount > 1:\\n\\t \\tupload(tmpFileName, bucket)\\n\\n\\tos.remove(tmpFileName)\",\n \"def partition_girvan_newman(graph, max_depth):\\n ###TODO\\n pass\",\n \"def make_master_flats(dc):\\n\\n\\t## Make EXTcheck: is there always the same number of extensions in each file\\n\\tprint \\\"Making master flats\\\"\\n\\t\\n\\t## Choose extensions you are using\\n\\t\\n\\tfor flat_type in ['FFS']: # Currently FFD is unsupported. If you have FFDs, add them to the list but you must have ONLY FFDs or ONLY FFSs in the dir. Otherwise the first element in the list will get overwritten!\\n\\t\\t#~ print \\\"\\\\n\\\", flat_type, \\\"\\\\n\\\"\\n\\t\\tfor i in dc:\\n\\t\\t\\tTRIM, TRIM1, VR, PS, PS1, OS, OS1 = CCD_sections((i[0], i[1]))\\n\\t\\t\\tfilelist = []\\n\\t\\t\\tfor f in glob.glob(RAW+'*'+flat_type+'*fits'):\\n\\t\\t\\t\\tccd_conf = []\\n\\t\\t\\t\\theader0 = fits.getheader(f)\\n\\t\\t\\t\\theader1 = fits.getheader(f, ext=1)\\n\\t\\t\\t\\tif header0['OBSMODE']==flat_type:\\n\\t\\t\\t\\t\\tfor KW in ['BINX', 'BINY']:\\n\\t\\t\\t\\t\\t\\tccd_conf.append(header0[KW])\\n\\t\\t\\t\\t\\tfor KW in ['NAXIS1', 'NAXIS2']:\\n\\t\\t\\t\\t\\t\\tccd_conf.append(header1[KW])\\n\\t\\t\\t\\t\\t\\tif tuple(ccd_conf)==i:\\n\\t\\t\\t\\t\\t\\t\\tfilelist.append(f)\\n\\t\\t\\tlfl = len(filelist)\\n\\t\\t\\tif lfl > 0:\\n\\t\\t\\t\\tBIN=CD+'/'+str(i[0])+'x'+str(i[1])+'/'\\n\\t\\t\\t\\tWD=BIN+str(i[-2])+'x'+str(i[-1])+'/' # Bottom level dir with calibrated and master frames\\n\\t\\t\\t\\tB=check_exist(WD, 'MF.fits', i)\\n\\t\\t\\t\\tif B=='n':\\n\\t\\t\\t\\t\\tpass\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\thdul = fits.HDUList()\\n\\t\\t\\t\\t\\thdul.append(fits.ImageHDU())\\n\\t\\t\\t\\t\\t#~ MB = fits.open(WD+'MB.fits')\\n\\t\\t\\t\\t\\tx = np.array(range(0,i[-1]))\\n\\t\\t\\t\\t\\tfor EXT in (extensions):\\n\\t\\t\\t\\t\\t\\tprint \\\"##################################################\\\"\\n\\t\\t\\t\\t\\t\\tprint \\\"Stacking \\\"+`lfl`+' '+`i[-2]`+'x'+`i[-1]`+' channel '+`EXT`+' flat frames!'\\n\\t\\t\\t\\t\\t\\tif EXT==1:\\n\\t\\t\\t\\t\\t\\t\\tPSC=PS1\\n\\t\\t\\t\\t\\t\\t\\tOSC=OS1\\n\\t\\t\\t\\t\\t\\t\\tTR=TRIM1\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tPSC=PS1\\n\\t\\t\\t\\t\\t\\t\\tOSC=OS\\n\\t\\t\\t\\t\\t\\t\\tTR=TRIM\\n\\t\\t\\t\\t\\t\\tsc = -1 # counts how many flats have mean>limit\\n\\t\\t\\t\\t\\t\\tfor n, fn in enumerate(filelist):\\n\\t\\t\\t\\t\\t\\t\\tprint \\\"Files left:\\\",`lfl-n`+'/'+`lfl`\\n\\t\\t\\t\\t\\t\\t\\tim = fits.getdata(fn, ext=EXT)\\n\\t\\t\\t\\t\\t\\t\\tmeanval = np.mean(im[VR[0]:VR[1], TR[0]:TR[1]])\\n\\t\\t\\t\\t\\t\\t\\t#~ maxval = np.max(im[VR[0]:VR[1], TR[0]:TR[1]])\\n\\t\\t\\t\\t\\t\\t\\tmaxval = stats.scoreatpercentile(im[VR[0]:VR[1], TR[0]:TR[1]], 90)\\n\\t\\t\\t\\t\\t\\t\\texptime = fits.getheader(fn)['EXPTIME']\\n\\t\\t\\t\\t\\t\\t\\t#~ if meanval > 15000. and meanval < 40000. and maxval < 50000. and exptime>5.:\\n\\t\\t\\t\\t\\t\\t\\tif meanval > 16000. and meanval < 40000. and exptime>=5.:\\n\\t\\t\\t\\t\\t\\t\\t\\tsc+=1\\n\\t\\t\\t\\t\\t\\t\\t\\t#~ im[im<1]=1\\n\\t\\t\\t\\t\\t\\t\\t\\tmscrow, sigmarow = median_row(OSC, PSC, TR, im)\\n\\t\\t\\t\\t\\t\\t\\t\\tsh = np.shape(im)\\n\\t\\t\\t\\t\\t\\t\\t\\tfor y in range(0, sh[0]):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tim[y] = im[y]-mscrow[y]\\n\\t\\t\\t\\t\\t\\t\\t\\tF=im\\n\\t\\t\\t\\t\\t\\t\\t\\tnorm = np.median(F[VR[0]:VR[1], TR[0]:TR[1]])\\n\\t\\t\\t\\t\\t\\t\\t\\tF = F/norm #+np.min(F)+0.0001\\n\\t\\t\\t\\t\\t\\t\\t\\tif sc==0:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tstack_arr = F\\n\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tstack_arr = np.dstack((stack_arr, F))\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\tprint \\\"****************************************\\\"\\n\\t\\t\\t\\t\\t\\t\\t\\tprint \\\"Rejected\\\", fn, \\\"AVG =\\\", meanval, \\\"EXPTIME =\\\", exptime\\n\\t\\t\\t\\t\\t\\t\\t\\tprint \\\"****************************************\\\"\\n\\t\\t\\t\\t\\t\\tprint 'Will stack a total of', np.shape(stack_arr)[2], 'flats'\\n\\t\\t\\t\\t\\t\\tMF = np.median(stack_arr, axis=2)\\n\\t\\t\\t\\t\\t\\thdul.append(fits.ImageHDU(MF))\\n\\t\\t\\t\\t\\t\\thdul[EXT].header.set(\\\"NAXIS1\\\", np.shape(MF)[1])\\n\\t\\t\\t\\t\\t\\thdul[EXT].header.set(\\\"NAXIS2\\\", np.shape(MF)[0])\\n\\t\\t\\t\\t\\thdul[0].header.set(\\\"CALIBR\\\", \\\"T\\\")\\n\\t\\t\\t\\t\\thdul[0].header.set(\\\"INSTRUME\\\", \\\"MAIA\\\")\\n\\t\\t\\t\\t\\thdul[0].header.set(\\\"BINX\\\", i[0])\\n\\t\\t\\t\\t\\thdul[0].header.set(\\\"BINY\\\", i[1])\\n\\t\\t\\t\\t\\thdul[0].header.set(\\\"CALMODE\\\", \\\"MASTER FLAT\\\")\\n\\t\\t\\t\\t\\thdul.writeto(WD+\\\"MF.fits\\\", clobber=True)\\n\\t\\t\\t\\t\\tprint \\\"############################################################\\\"\\n\\tprint \\\"Completed master flats\\\"\",\n \"def test_build_children_state_downloaded_partial_extra(self):\\n r_a = SystemFile(\\\"a\\\", 300, True)\\n r_aa = SystemFile(\\\"aa\\\", 100, True)\\n r_a.add_child(r_aa)\\n r_aaa = SystemFile(\\\"aaa\\\", 100, False)\\n r_aa.add_child(r_aaa)\\n r_ab = SystemFile(\\\"ab\\\", 200, False)\\n r_a.add_child(r_ab)\\n\\n l_a = SystemFile(\\\"a\\\", 350, True)\\n l_aa = SystemFile(\\\"aa\\\", 50, True)\\n l_a.add_child(l_aa)\\n l_aaa = SystemFile(\\\"aaa\\\", 50, False)\\n l_aa.add_child(l_aaa)\\n l_ab = SystemFile(\\\"ab\\\", 200, False)\\n l_a.add_child(l_ab)\\n l_ac = SystemFile(\\\"ac\\\", 100, True) # local only\\n l_a.add_child(l_ac)\\n l_aca = SystemFile(\\\"aca\\\", 100, False) # local only\\n l_ac.add_child(l_aca)\\n\\n self.model_builder.set_remote_files([r_a])\\n self.model_builder.set_local_files([l_a])\\n\\n model = self.model_builder.build_model()\\n m_a = model.get_file(\\\"a\\\")\\n self.assertEqual(ModelFile.State.DEFAULT, m_a.state)\\n m_a_ch = {m.name: m for m in model.get_file(\\\"a\\\").get_children()}\\n m_aa = m_a_ch[\\\"aa\\\"]\\n self.assertEqual(ModelFile.State.DEFAULT, m_aa.state)\\n m_aaa = m_aa.get_children()[0]\\n self.assertEqual(ModelFile.State.DEFAULT, m_aaa.state)\\n m_ab = m_a_ch[\\\"ab\\\"]\\n self.assertEqual(ModelFile.State.DOWNLOADED, m_ab.state)\\n m_ac = m_a_ch[\\\"ac\\\"]\\n self.assertEqual(ModelFile.State.DEFAULT, m_ac.state)\\n m_aca = m_ac.get_children()[0]\\n self.assertEqual(ModelFile.State.DEFAULT, m_aca.state)\",\n \"def baseline_rechunk(indir_path, outdir_path, O, I, R, file_format, addition, distributed, debug_mode=False, clean_out_dir=False, dont_write=False):\\n\\n print(f\\\"Setting arguments...\\\")\\n global DEBUG_LOCAL\\n global DONT_WRITE\\n global tracker\\n global outdirs_dict, outdir_index\\n outdirs_dict = dict()\\n outdir_index = 0\\n tracker = Tracker()\\n DEBUG_LOCAL = True if debug_mode else False\\n DONT_WRITE = True if dont_write else False\\n\\n print(\\\"Addition mode:\\\", addition)\\n print(\\\"DONT_WRITE: \\\", DONT_WRITE)\\n\\n O, I, R = tuple(O), tuple(I), tuple(R)\\n\\n file_manager = get_file_manager(file_format)\\n\\n infiles_partition = get_blocks_shape(R, I)\\n infiles_volumes = get_named_volumes(infiles_partition, I)\\n outfiles_partition = get_blocks_shape(R, O)\\n outfiles_volumes = get_named_volumes(outfiles_partition, O)\\n outfiles_volumes = outfiles_volumes.values()\\n\\n if distributed:\\n repartition_dict = None\\n \\n json_filename = '/disk0/gtimothee/repartition_dict.json'\\n if not os.path.isfile(json_filename):\\n # print(\\\"cannot find association dict json file\\\")\\n sys.exit(1)\\n else:\\n pass # print(f\\\"json file found\\\")\\n\\n try: \\n with open(json_filename) as f:\\n repartition_dict = json.load(f)\\n except Exception as e: \\n print(e)\\n # print(\\\"error (1)\\\")\\n sys.exit(1)\\n\\n if repartition_dict == None:\\n # print(\\\"error (2)\\\")\\n sys.exit(1)\\n else:\\n pass # print(f\\\"Found reparition dict: {repartition_dict}\\\")\\n\\n input_files = repartition_dict.values()\\n else:\\n input_files = file_manager.get_input_files(indir_path)\\n\\n t_read = 0\\n t_write = 0\\n\\n vols_written = list()\\n nb_infile_openings = 0\\n nb_infile_seeks = 0\\n nb_outfile_openings = 0\\n nb_outfile_seeks = 0\\n buffer_index = 1\\n for input_file in input_files:\\n print(f\\\"Treating buffer: {buffer_index}...\\\")\\n buffer_index += 1\\n nb_infile_openings += 1\\n\\n involume = get_volume(input_file, infiles_volumes, infiles_partition)\\n t1 = time.time()\\n if not DONT_WRITE:\\n data = file_manager.read_data_from_fp(input_file, slices=None)\\n else:\\n data = None\\n t1 = time.time() - t1\\n t_read += t1\\n \\n for outvolume in outfiles_volumes:\\n if hypercubes_overlap(involume, outvolume):\\n shape, t2, nb_outfile_seeks_tmp = write_to_outfile(involume, outvolume, data, outfiles_partition, outdir_path, O, file_manager, addition, tracker)\\n t_write += t2\\n vols_written.append(shape)\\n # nb_outfile_openings += 1 already included in nb_outfile_seeks\\n nb_outfile_seeks += nb_outfile_seeks_tmp\\n \\n file_manager.close_infiles()\\n\\n if DONT_WRITE:\\n assert tracker.is_complete(((0,0,0), R))\\n\\n # print(\\\"\\\\nShapes written:\\\")\\n # for row in vols_written: \\n # print(row)\\n\\n if clean_out_dir:\\n print(\\\"Cleaning output directory\\\")\\n file_manager.clean_directory(outdir_path)\\n\\n get_opened_files()\\n\\n return t_read, t_write, [nb_outfile_openings, nb_outfile_seeks, nb_infile_openings, nb_infile_seeks]\",\n \"def generate_structure(flag):\\r\\n if os.path.isfile(\\\"packing.nfo\\\"):\\r\\n os.remove(os.path.abspath(\\\"packing.nfo\\\"))\\r\\n proc = subprocess.Popen(['PackingGeneration.exe', flag])\\r\\n proc.wait()\\r\\n if not os.path.isfile(\\\"packing.nfo\\\"):\\r\\n print('Try to change number of particles or size distribution.')\\r\\n raise Exception('Packing algorithm failed.')\",\n \"def main():\\n\\n ##############################\\n # Options\\n ##############################\\n # Validation set\\n input_depth_dir = os.path.expanduser(\\n '~/Kitti/depth/train')\\n data_split = 'val'\\n\\n # Test set\\n # input_depth_dir = os.path.expanduser(\\n # '~/Kitti/depth/depth_selection/test_depth_completion_anonymous/velodyne_raw')\\n # data_split = 'test'\\n\\n # Fast fill with Gaussian blur @90Hz (paper result)\\n fill_type = 'fast'\\n extrapolate = True\\n blur_type = 'gaussian'\\n\\n # Fast Fill with bilateral blur, no extrapolation @87Hz (recommended)\\n # fill_type = 'fast'\\n # extrapolate = False\\n # blur_type = 'bilateral'\\n\\n # Multi-scale dilations with extra noise removal, no extrapolation @ 30Hz\\n # fill_type = 'multiscale'\\n # extrapolate = False\\n # blur_type = 'bilateral'\\n\\n # Save output to disk or show process\\n save_output = True\\n\\n ##############################\\n # Processing\\n ##############################\\n if save_output:\\n # Save to Disk\\n show_process = False\\n save_depth_maps = True\\n else:\\n if fill_type == 'fast':\\n raise ValueError('\\\"fast\\\" fill does not support show_process')\\n\\n # Show Process\\n show_process = True\\n save_depth_maps = False\\n\\n # Create output folder\\n this_file_path = os.path.dirname(os.path.realpath(__file__))\\n outputs_dir = this_file_path + '/outputs'\\n os.makedirs(outputs_dir, exist_ok=True)\\n\\n output_folder_prefix = 'depth_' + data_split\\n output_list = sorted(os.listdir(outputs_dir))\\n if len(output_list) > 0:\\n split_folders = [folder for folder in output_list\\n if folder.startswith(output_folder_prefix)]\\n if len(split_folders) > 0:\\n last_output_folder = split_folders[-1]\\n last_output_index = int(last_output_folder.split('_')[-1])\\n else:\\n last_output_index = -1\\n else:\\n last_output_index = -1\\n output_depth_dir = outputs_dir + '/{}_{:03d}'.format(\\n output_folder_prefix, last_output_index + 1)\\n\\n if save_output:\\n if not os.path.exists(output_depth_dir):\\n os.makedirs(output_depth_dir)\\n else:\\n raise FileExistsError('Already exists!')\\n print('Output dir:', output_depth_dir)\\n\\n # Get images in sorted order\\n # images_to_use = sorted(glob.glob(input_depth_dir + '/*'))\\n\\n # Rolling average array of times for time estimation\\n avg_time_arr_length = 10\\n last_fill_times = np.repeat([1.0], avg_time_arr_length)\\n last_total_times = np.repeat([1.0], avg_time_arr_length)\\n\\n images_to_use = []\\n saved_path = []\\n folder_path =\\\"./data_depth_selection/depth_selection/test_depth_completion_anonymous/velodyne_raw\\\"\\n for img_name in os.listdir(folder_path):\\n img_path = os.path.join(folder_path,img_name)\\n saved_path_name = os.path.join(\\\"./output\\\", img_name)\\n saved_path.append(saved_path_name)\\n images_to_use.append(img_path)\\n # if \\\"output\\\" not in os.listdir(\\\"Kitti/depth/\\\"):\\n # os.mkdir(\\\"Kitti/depth/output\\\")\\n # os.mkdir(\\\"output\\\")\\n # for folder in os.listdir(folder_path):\\n # # os.mkdir(\\\"./output/\\\"+folder)\\n # # os.mkdir(\\\"./output/\\\"+folder+\\\"/2011_09_26/\\\")\\n # # os.mkdir(\\\"./output/\\\"+folder+\\\"/2011_09_26/\\\"+folder+\\\"/\\\")\\n\\n # inside_folder_path = folder_path + \\\"/\\\" + folder+\\\"/2011_09_26/\\\"+folder+\\\"/\\\"\\n # for img_folder in os.listdir(inside_folder_path):\\n # print((\\\"/output/\\\"+folder+\\\"/2011_09_26/\\\"+folder+\\\"/\\\"+img_folder))\\n # # os.mkdir(\\\"./output/\\\"+folder+\\\"/2011_09_26/\\\"+folder+\\\"/\\\"+img_folder)\\n # print(inside_folder_path + img_folder)\\n # # os.mkdir(\\\"Kitti/depth/output/\\\"+folder+\\\"/proj_depth/groundtruth/\\\"+img_folder)\\n # img_path = inside_folder_path + img_folder+\\\"/data\\\"\\n # try:\\n # print(\\\"............................................................\\\",\\\"./depth_images/train/\\\" + folder + \\\"/proj_depth/groundtruth/\\\"+img_folder)\\n # depth_image_folder = os.listdir(\\\"./depth_images/train/\\\" + folder + \\\"/proj_depth/groundtruth/\\\"+img_folder)\\n # # print(depth_image_folder)\\n # for img in os.listdir(img_path):\\n # # image_path = +\\\"/\\\"+img\\n # # print(img)\\n # if img in depth_image_folder:\\n # # print(\\\"aaya\\\")\\n # depth_image_path = \\\"./depth_images/train/\\\" + folder + \\\"/proj_depth/groundtruth/\\\"+img_folder+\\\"/\\\"+img\\n # images_to_use.append(depth_image_path)\\n # saved_path.append(\\\"./output/\\\"+folder+\\\"/2011_09_26/\\\"+folder+\\\"/\\\"+img_folder+\\\"/\\\"+img)\\n # except Exception:\\n # print(\\\"folder nahi hai\\\")\\n \\n images_to_use = np.array(images_to_use)\\n \\n num_images = len(images_to_use)\\n\\n print(len(images_to_use))\\n\\n\\n for i in range(num_images):\\n\\n depth_image_path = images_to_use[i]\\n\\n # Calculate average time with last n fill times\\n avg_fill_time = np.mean(last_fill_times)\\n avg_total_time = np.mean(last_total_times)\\n\\n # Show progress\\n sys.stdout.write('\\\\rProcessing {} / {}, '\\n 'Avg Fill Time: {:.5f}s, '\\n 'Avg Total Time: {:.5f}s, '\\n 'Est Time Remaining: {:.3f}s'.format(\\n i, num_images - 1, avg_fill_time, avg_total_time,\\n avg_total_time * (num_images - i)))\\n sys.stdout.flush()\\n\\n # Start timing\\n start_total_time = time.time()\\n print(depth_image_path)\\n # Load depth projections from uint16 image\\n depth_image = cv2.imread(depth_image_path, cv2.IMREAD_ANYDEPTH)\\n projected_depths = np.float32(depth_image / 256.0)\\n\\n # Fill in\\n start_fill_time = time.time()\\n if fill_type == 'fast':\\n final_depths = depth_map_utils.fill_in_fast(\\n projected_depths, extrapolate=extrapolate, blur_type=blur_type)\\n elif fill_type == 'multiscale':\\n final_depths, process_dict = depth_map_utils.fill_in_multiscale(\\n projected_depths, extrapolate=extrapolate, blur_type=blur_type,\\n show_process=show_process)\\n else:\\n raise ValueError('Invalid fill_type {}'.format(fill_type))\\n end_fill_time = time.time()\\n\\n # Display images from process_dict\\n if fill_type == 'multiscale' and show_process:\\n img_size = (570, 165)\\n\\n x_start = 80\\n y_start = 50\\n x_offset = img_size[0]\\n y_offset = img_size[1]\\n x_padding = 0\\n y_padding = 28\\n\\n img_x = x_start\\n img_y = y_start\\n max_x = 1900\\n\\n row_idx = 0\\n for key, value in process_dict.items():\\n\\n image_jet = cv2.applyColorMap(\\n np.uint8(value / np.amax(value) * 255),\\n cv2.COLORMAP_JET)\\n vis_utils.cv2_show_image(\\n key, image_jet,\\n img_size, (img_x, img_y))\\n\\n img_x += x_offset + x_padding\\n if (img_x + x_offset + x_padding) > max_x:\\n img_x = x_start\\n row_idx += 1\\n img_y = y_start + row_idx * (y_offset + y_padding)\\n\\n # Save process images\\n cv2.imwrite('process/' + key + '.png', image_jet)\\n\\n cv2.waitKey()\\n\\n # Save depth images to disk\\n if save_depth_maps:\\n depth_image_file_name = depth_image_path.split(\\\"/\\\")\\n # print(depth_image_file_name)\\n file_path = \\\"\\\"\\n print(len(depth_image_file_name))\\n # for i in range(8):\\n # if(i == 2):\\n # file_path = os.path.join(file_path, \\\"output\\\")\\n # else:\\n # file_path = os.path.join(file_path, depth_image_file_name[i])\\n # cv2.imwrite(file_path, depth_image)\\n # print(\\\"check.............................\\\",saved_path[i])\\n # with open(saved_path[i],'r') as f:\\n # print(\\\"badhiya\\\") \\n depth_image = (final_depths * 256)\\n # plt.imsave(saved_path[i],depth_image)\\n # cv2.imwrite(saved_path[i], depth_image)\\n # print(saved_path[i])\\n # cv2.imwrite(\\\"/media/pankaj/Elements/ip_basic\\\"+saved_path[i], depth_image)\\n \\n try:\\n with open(saved_path[i], 'wb') as f:\\n depth_image = (final_depths * 256).astype(np.uint16)\\n\\n writer = png.Writer(width=depth_image.shape[1],\\n height=depth_image.shape[0],\\n bitdepth=16,\\n greyscale=True)\\n writer.write(f, depth_image)\\n except Exception:\\n print(\\\"nikl.............\\\")\\n\\n end_total_time = time.time()\\n\\n # Update fill times\\n last_fill_times = np.roll(last_fill_times, -1)\\n last_fill_times[-1] = end_fill_time - start_fill_time\\n\\n # Update total times\\n last_total_times = np.roll(last_total_times, -1)\\n last_total_times[-1] = end_total_time - start_total_time\",\n \"def test_launch_config_personality_with_max_path_size(self):\\n long_path = 'z' * (self.personality_maxlength + 1)\\n personality = [{'path': '/root/{0}.txt'.format(long_path),\\n 'contents': base64.b64encode('tests')}]\\n self._assert_create_group(personality)\",\n \"def set_depth(self, depth):\\n self._depth = depth\\n if self._scaled_image_coordinates is None:\\n self._initialise()\\n else:\\n self._update_depth()\",\n \"def update_pkg(dir_layout:dict, source_path:Path, dest_path:Path, dry_run=True, exclude=[]):\\n for folder_name, data in dir_layout.items():\\n print(f\\\"DIR: {folder_name}\\\")\\n print(f\\\"SRC: {source_path}\\\")\\n print(f\\\"DST: {dest_path}\\\")\\n for item in iterate_files(data):\\n match = function_name_pattern.search(item)\\n if match:\\n # Use recursive Unix-like glob matching to find exact paths \\n # files in source directory using matched file name.\\n function_name = match.group(1)\\n else:\\n function_name = os.path.splitext(item)[0]\\n\\n sources = list(source_path.glob(\\\"**/\\\"+function_name+\\\".?\\\"))\\n\\n if sources: # Check that a matching file was found.\\n if len(sources)>1:\\n # Possibly picked up .p files, extract only '.m' files.\\n sources = [s for s in sources if s.suffix == \\\".m\\\"]\\n for excl_pattern in exclude:\\n print(f\\\">>> Excluding '{excl_pattern}'\\\")\\n sources = [s for s in sources if not fnmatch.fnmatch(s, excl_pattern)]\\n assert len(sources) == 1, sources\\n source = sources[0]\\n # concatenate destination path\\n destination = dest_path/folder_name/os.path.split(source)[1]\\n print(f\\\" source: {source}\\\")\\n print(f\\\" dest: {destination}\\\\n\\\")\\n\\n if not dry_run:\\n os.makedirs(os.path.dirname(destination),exist_ok=True)\\n shutil.copy(source,destination)\\n else:\\n print(f\\\"FILE NOT FOUND: {function_name}\\\")\\n\\n if isinstance(data, dict) and is_dir(data):\\n update_pkg(data,source_path,dest_path/folder_name, dry,exclude=exclude)\",\n \"def __init__(self, filenameOrPath, dirPath=None, compresslevel=9, logger=None, verbose=True, indent=None, closeAtEachAppend=True):\\n\\t\\tself.closeAtEachAppend = closeAtEachAppend\\n\\t\\tself.writeFile = None\\n\\t\\tself.indent = indent\\n\\t\\tself.logger = logger\\n\\t\\tself.verbose = verbose\\n\\t\\tself.compresslevel = compresslevel\\n\\t\\tself.alreadyWarnedAboutMoSize = False\\n\\t\\tif self.compresslevel is None:\\n\\t\\t\\tself.compresslevel = 0\\n\\t\\tif filenameOrPath is None:\\n\\t\\t\\traise Exception(\\\"filenameOrPath param is None\\\")\\n\\t\\tif \\\"/\\\" in filenameOrPath and dirPath is not None:\\n\\t\\t\\traise Exception(\\\"Don't use a path in bot fileNameOrPath and dirPath\\\")\\n\\t\\tif \\\"/\\\" in filenameOrPath and not (filenameOrPath[-4:] == \\\".bz2\\\" or filenameOrPath[-7:] == \\\".ndjson\\\"):\\n\\t\\t\\traise Exception(\\\"Please use bz2 or ndjson extensions\\\")\\n\\t\\tif \\\"/\\\" in filenameOrPath and not (filenameOrPath.startswith(\\\"/\\\") or filenameOrPath.startswith(\\\"~\\\")):\\n\\t\\t\\traise Exception(\\\"Please give an absolute path\\\")\\n\\t\\tif \\\"/\\\" in filenameOrPath:\\n\\t\\t\\t(dirPath, filename, ext, _) = decomposePath2(filenameOrPath)\\n\\t\\telse:\\n\\t\\t\\tif dirPath is None:\\n\\t\\t\\t\\tdirPath = tmpDir()\\n\\t\\t\\tif len(filenameOrPath) > 4 and filenameOrPath[-4:] == \\\".bz2\\\":\\n\\t\\t\\t\\tfilename = filenameOrPath[:-4]\\n\\t\\t\\t\\text = \\\"bz2\\\"\\n\\t\\t\\telif len(filenameOrPath) > 7 and filenameOrPath[-7:] == \\\".ndjson\\\":\\n\\t\\t\\t\\tfilename = filenameOrPath[:-7]\\n\\t\\t\\t\\text = \\\"ndjson\\\"\\n\\t\\t\\telse:\\n\\t\\t\\t\\tfilename = filenameOrPath\\n\\t\\t\\t\\tif self.compresslevel > 0:\\n\\t\\t\\t\\t\\text = \\\"bz2\\\"\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\text = \\\"ndjson\\\"\\n\\t\\tself.path = dirPath + \\\"/\\\" + filename + \\\".\\\" + ext\\n\\t\\tif ext != \\\"bz2\\\":\\n\\t\\t\\tif self.compresslevel > 0:\\n\\t\\t\\t\\tlogWarning(\\\"We will not compress \\\" + self.path, self)\\n\\t\\t\\tself.compresslevel = 0\\n\\t\\tself.estimatedSizeRefreshCount = 0\\n\\t\\tself.previousMoSize = None\",\n \"def __write_files(self, kind:str, prog:progress=None):\\n\\t\\tself.written_sectors = 0\\n\\t\\tself.write_elapsed = 0.0\\t\\t\\t\\t\\n\\t\\tself.filematrix.reset(kind == 'dynamic')\\t\\n\\t\\tself.__ipc_send_progress(prog, 0)\\n\\n\\t\\twhile not self.filematrix.done():\\t\\t\\n\\t\\t\\tif (self.__check_terminated()):\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\tfp = self.filematrix.next()\\n\\n\\t\\t\\tif (kind == 'all'):\\n\\t\\t\\t\\tif (self.prev_mode != self.filematrix.current.mode):\\n\\t\\t\\t\\t\\tif (self.filematrix.current.mode == fsmode.dynamic):\\n\\t\\t\\t\\t\\t\\tself.__ipc_send_status(\\\"Write all files - DYNAMIC\\\")\\t\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tself.__ipc_send_status(\\\"Write all files - STATIC\\\")\\t\\n\\n\\t\\t\\t\\t\\tself.prev_mode = self.filematrix.current.mode \\t\\t\\t\\t\\t\\t\\n\\n\\t\\t\\t####logging.info('write path:' + fp.path + ', size: ' + str(fp.size) + ', seed: ' + str(fp.rand_seed))\\n\\n\\t\\t\\tif not os.path.exists(fp.folder):\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tos.mkdir(fp.folder)\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\t raise_error(FileNotFoundError, myerror.dir_error, \\\"create directory fail\\\")\\n\\t\\t\\telif not os.access(fp.folder, os.F_OK):\\n\\t\\t\\t\\tos.mkdir(fp.folder)\\t\\n\\t\\t\\t\\t\\n\\t\\t\\ttime.sleep(0.001)\\t\\t\\t\\t\\n\\t\\t\\t\\t\\n\\t\\t\\t#try:\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t#\\twith iolib.fopen(fp.path, 'wb') as f:\\n\\t\\t\\t#\\t\\tpass\\t\\t\\t\\t\\n\\t\\t\\t#except (PermissionError) as err:\\t\\t\\t\\n\\t\\t\\t#\\traise_error(PermissionError, myerror.dir_error, str(err))\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\n\\t\\t\\twith iolib.fopen(fp.path, 'wb') as f:\\n\\t\\t\\t\\tremain = fp.size\\n\\t\\t\\t\\tfile_time = 0.0\\n\\t\\t\\t\\tstart = 0.0\\n\\t\\t\\t\\telapsed = 0.0\\n\\t\\t\\t\\t\\n\\t\\t\\t\\twhile (remain != 0):\\n\\t\\t\\t\\t\\tif (self.__check_terminated()):\\n\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\tchunk_sectors = min(remain, self.max_buff_size)\\t\\t\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tbuff = self.__random_chunk_pattern(chunk_sectors, fp.rand_seed)\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t#buff = self.__next_chunk_pattern(chunk_sectors)\\t\\n\\t\\t\\t\\t\\twritten, elapsed = iolib.write(buff, 512, chunk_sectors, f)\\n\\t\\t\\t\\t\\tfile_time += elapsed\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\n\\t\\t\\t\\t\\tself.written_sectors += int(written)\\n\\t\\t\\t\\t\\tremain = remain - chunk_sectors\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tself.write_elapsed += file_time\\n\\t\\t\\n\\t\\t\\t\\ttime.sleep(0.001)\\n\\t\\t\\t\\n\\t\\t\\tself.__ipc_send_progress(prog, self.filematrix.get_progress())\",\n \"def SetToolPacking(self, packing):\\r\\n\\r\\n self._tool_packing = packing\",\n \"def mark_best(run_directory: Union[str, Path]) -> None:\\n run_directory = Path(run_directory).resolve()\\n mark_best_explicit(run_directory, run_directory.parent)\",\n \"def pkgOverride(self, keyList = None, pkgFlag = True, titleFlag = None):\\n\\n # Quick and dirty check for list type.\\n if type(keyList) is not list:\\n keyList = [keyList]\\n\\n\\n print('\\\\n***Packaging override...')\\n\\n # Manual set for pkg override of selected jobs\\n for key in keyList:\\n print(f\\\"\\\\n***Job {key}: {self.nbDetails[key]['title']}\\\")\\n print(self.nbDetails[key]['jobInfo'])\\n\\n # Check and change title if desired\\n if titleFlag is None:\\n # Manual title overrides, ugh.\\n titleFlag = input(\\\"Change title? (y/n) \\\")\\n if titleFlag == 'y': titleFlag = True\\n else: titleFlag = False\\n\\n\\n if titleFlag:\\n test = input(f\\\"Suggested title: {self.nbDetails[key]['jobInfo'][3].strip().rsplit(',',1)[0]} (y/n)\\\")\\n\\n if test == 'y':\\n # For old-style jobs, use longer version of title\\n # self.nbDetails[key]['title'] = self.nbDetails[key]['jobInfo'][3].strip().rsplit(',',1)[0]\\n # Version + energy range.\\n self.nbDetails[key]['title'] = self.nbDetails[key]['jobInfo'][3].strip().rsplit(',',1)[0] + f\\\", {self.nbDetails[key]['E'][0]} - {self.nbDetails[key]['E'][2]} eV\\\"\\n else:\\n self.nbDetails[key]['title'] = input(\\\"New title? \\\")\\n\\n if pkgFlag:\\n\\n # Set for packaging\\n self.nbDetails[key]['pkg'] = True\\n self.nbDetails[key]['repo'] = 'Zenodo'\\n print(\\\"Set pkg = True\\\")\\n\\n # Override arch check\\n if 'archFileCheck' in self.nbDetails[key].keys():\\n print(f\\\"Arch file check: {self.nbDetails[key]['archFileCheck']}\\\")\\n print(f\\\"Arch files OK: {self.nbDetails[key]['archFilesOK']}\\\")\\n print(\\\"Setting to True\\\")\\n self.nbDetails[key]['archFileCheck'] = True\\n self.nbDetails[key]['archFilesOK'] = True\\n else:\\n print(f\\\"Arch files not yet set and checked - run this again after updateUploads().\\\")\\n\\n\\n # Reset eStructure\\n # job.setESFiles(eSourceDir=job.hostDefn[job.host]['jobDir']/'electronic_structure', verbose=True)\\n\\n # job.nbDetails[5]['pkg'] = False\\n # job.delRepoItem(4)\\n # Rewrite JSON\\n # Update remote\\n self.writeNBdetailsJSON()\",\n \"def __init__(self, output_dir, fstype, num_disks, num_dirs):\\n super(PostMarkTest, self).__init__(fstype, num_disks)\\n self.num_dirs = num_dirs\\n self.output_dir = output_dir\\n self.configurations = []\",\n \"def increment_depth(self):\\r\\n self.depth = self.depth + 1\",\n \"def get_max_depth(self):\\n return self.MAX_DEPTH\",\n \"def test_launch_config_personality_with_max_file_content_size(self):\\n file_content = 'z' * (self.personality_max_file_size + 1)\\n personality = [{'path': self.path,\\n 'contents': base64.b64encode(file_content)}]\\n self._assert_create_group(personality)\",\n \"def algorithm(self, groupInstance = None, jobInstance = None,\\n *args, **kwargs):\\n # extract some global scheduling parameters\\n self.jobNamePrefix = kwargs.get('jobNamePrefix', \\\"Repack\\\")\\n self.maxSizeSingleLumi = kwargs['maxSizeSingleLumi']\\n self.maxSizeMultiLumi = kwargs['maxSizeMultiLumi']\\n self.maxInputEvents = kwargs['maxInputEvents']\\n self.maxInputFiles = kwargs['maxInputFiles']\\n self.maxLatency = kwargs['maxLatency']\\n\\n self.currentTime = time.time()\\n\\n self.createdGroup = False\\n\\n timePerEvent, sizePerEvent, memoryRequirement = \\\\\\n self.getPerformanceParameters(kwargs.get('performance', {}))\\n \\n myThread = threading.currentThread()\\n daoFactory = DAOFactory(package = \\\"T0.WMBS\\\",\\n logger = logging,\\n dbinterface = myThread.dbi)\\n\\n # keep for later\\n self.insertSplitLumisDAO = daoFactory(classname = \\\"JobSplitting.InsertSplitLumis\\\")\\n\\n # data discovery\\n getAvailableFilesDAO = daoFactory(classname = \\\"Subscriptions.GetAvailableRepackFiles\\\")\\n availableFiles = getAvailableFilesDAO.execute(self.subscription[\\\"id\\\"])\\n\\n # nothing to do, stop immediately\\n if len(availableFiles) == 0:\\n return\\n\\n # data discovery for already used lumis\\n getUsedLumisDAO = daoFactory(classname = \\\"Subscriptions.GetUsedLumis\\\")\\n usedLumis = getUsedLumisDAO.execute(self.subscription[\\\"id\\\"], False)\\n\\n # empty lumis (as declared by StorageManager) are treated the\\n # same way as used lumis, ie. we process around them\\n getEmptyLumisDAO = daoFactory(classname = \\\"Subscriptions.GetLumiHolesForRepack\\\")\\n usedLumis |= getEmptyLumisDAO.execute(self.subscription[\\\"id\\\"])\\n\\n # sort available files by lumi\\n availableFileLumiDict = {}\\n for result in availableFiles:\\n lumi = result['lumi']\\n if not lumi in availableFileLumiDict:\\n availableFileLumiDict[lumi] = []\\n availableFileLumiDict[lumi].append(result)\\n\\n # loop through lumis in order\\n haveLumiHole = False\\n filesByLumi = {}\\n maxUsedLumi = max(usedLumis) if usedLumis else 0\\n for lumi in range(1, 1+max(maxUsedLumi,max(availableFileLumiDict.keys()))):\\n\\n # lumi contains data => remember it for potential processing\\n if lumi in availableFileLumiDict:\\n\\n filesByLumi[lumi] = availableFileLumiDict[lumi]\\n\\n # lumi is used and we have data => trigger processing\\n elif lumi in usedLumis:\\n\\n if len(filesByLumi) > 0:\\n\\n if haveLumiHole:\\n # if lumi hole check for maxLatency first\\n if self.getDataAge(filesByLumi) > self.maxLatency:\\n self.defineJobs(filesByLumi, True, memoryRequirement)\\n filesByLumi = {}\\n # if maxLatency not met ignore data for now\\n else:\\n filesByLumi = {}\\n else:\\n self.defineJobs(filesByLumi, True, memoryRequirement)\\n filesByLumi = {}\\n\\n # if we had a lumi hole it is now not relevant anymore\\n # the next data will have a used lumi in front of it\\n haveLumiHole = False\\n\\n # lumi has no data and isn't used, ie. we have a lumi hole\\n # also has an impact on how to handle later data\\n else:\\n\\n if len(filesByLumi) > 0:\\n\\n # forceClose if maxLatency trigger is met\\n if self.getDataAge(filesByLumi) > self.maxLatency:\\n self.defineJobs(filesByLumi, True, memoryRequirement)\\n filesByLumi = {}\\n # follow the normal thresholds, but only if\\n # there is no lumi hole in front of the data\\n elif not haveLumiHole:\\n self.defineJobs(filesByLumi, False, memoryRequirement)\\n filesByLumi = {}\\n # otherwise ignore the data for now\\n else:\\n filesByLumi = {}\\n\\n haveLumiHole = True\\n\\n # now handle whatever data is still left (at the high end of the lumi range)\\n if haveLumiHole:\\n if self.getDataAge(filesByLumi) > self.maxLatency:\\n self.defineJobs(filesByLumi, True, memoryRequirement)\\n else:\\n fileset = self.subscription.getFileset()\\n fileset.load()\\n self.defineJobs(filesByLumi, not fileset.open, memoryRequirement)\\n\\n return\",\n \"def get_directory_limits():\\n pass\",\n \"def getMaxFile(self, channel):\\n maxSavePath, fileName = os.path.split(self.path)\\n baseFileName = os.path.splitext(fileName)[0]\\n maxSavePath = os.path.join(maxSavePath, 'max')\\n maxFileName = 'max_' + baseFileName + '_ch' + str(channel) + '.tif'\\n maxFilePath = os.path.join(maxSavePath, maxFileName)\\n return maxFilePath\",\n \"def max_depth(self) -> int:\\n return pulumi.get(self, \\\"max_depth\\\")\",\n \"def walkthrough(software_map):\\n\\n for i in software_map:\\n\\n if not i[\\\"is_file\\\"]:\\n\\n # for each directory: make a index.md\\n dname = \\\"./docs/\\\" + i[\\\"name\\\"]\\n index = \\\"./docs/\\\" + i[\\\"name\\\"] + \\\"/index.md\\\"\\n print(index)\\n os.mkdir(dname)\\n\\n with open(index, \\\"w+\\\") as f:\\n\\n children = i[\\\"children\\\"]\\n\\n # list files\\n f.write(\\\"Files:\\\\n\\\\n\\\")\\n for i in children:\\n if i[\\\"is_file\\\"]:\\n\\n fname = i[\\\"name\\\"]\\n fext = fname.split(\\\".\\\")\\n if len(fext) == 2:\\n fext = fext[1]\\n else:\\n fext = \\\"none\\\"\\n # for each file, note name and extension\\n f.write(fname + \\\" : \\\" + fext + \\\"\\\\n\\\")\\n\\n # list subdirectories\\n f.write(\\\"\\\\nSubdirectories:\\\\n\\\\n\\\")\\n for i in children:\\n if not i[\\\"is_file\\\"]:\\n\\n dirname = i[\\\"name\\\"]\\n\\n # note the number of files and subdirs in it\\n num_files, num_dirs = 0, 0\\n for child in i[\\\"children\\\"]:\\n if child[\\\"is_file\\\"]:\\n num_files += 1\\n elif not child[\\\"is_file\\\"]:\\n num_dirs += 1\\n\\n # note down name and numbers for each dir\\n f.write(dirname + \\\" : \\\" + str(num_files) + \\\" files, \\\" +\\n str(num_dirs) + \\\" directories\\\\n\\\")\\n\\n # goto subdir\\n if len(i[\\\"children\\\"]) > 0:\\n walkthrough(i[\\\"children\\\"])\",\n \"def depth(self, create, depth, **kwargs): # pylint: disable=unused-argument\\r\\n # pylint: disable=no-member\\r\\n if depth == 0:\\r\\n self.load_item.side_effect = lambda x: LeafModuleFactory(descriptor_cls=HtmlDescriptor)\\r\\n else:\\r\\n self.load_item.side_effect = lambda x: ContainerModuleFactory(descriptor_cls=VerticalDescriptor, depth=depth - 1)\",\n \"def max_weight(self):\\n raise NotImplementedError(\\\"subclasses need to override this method\\\")\",\n \"def update_level(self):\\n level = 1\\n assigned_levels = set([])\\n just_assigned = set([])\\n for root in self.roots:\\n for child in root.children:\\n if child in just_assigned:\\n continue\\n child.level = level\\n if len(child.children) == 0:\\n continue\\n just_assigned.add(child)\\n assigned_levels = assigned_levels.union(just_assigned)\\n\\n level += 1\\n leaves = [c for c in self.collectors if len(c.children) == 0]\\n len_non_leaves = len(self.collectors) - len(leaves)\\n self.update_level_for_non_leaves(\\n level, assigned_levels, just_assigned, len_non_leaves\\n )\",\n \"def main():\\n global MASK\\n start_time = time()\\n parser = initArgparse()\\n args = parser.parse_args()\\n dirtree = args.directorytree\\n filetree = args.filetree\\n meta = args.metadata\\n newmeta = args.newmetadata\\n sfv = args.sfv\\n yes = args.yes\\n MASK = args.exclude\\n\\n for i in args.DIRECTORY:\\n if Path(i).exists() is True:\\n basepath = Path(i)\\n else:\\n raise NotADirectoryError(f\\\"{i} does not exist\\\")\\n default = False\\n if dirtree == sfv == filetree == meta == newmeta is False:\\n default = True\\n if dirtree is True or default is True:\\n dirtree_file = f\\\"{basepath.name}_directory_tree.txt\\\"\\n checkFileExists(basepath, dirtree_file, yes)\\n createDirectoryTree(basepath, dirtree_file)\\n if sfv is True or default is True:\\n sfv_file = f\\\"{basepath.name}.sfv\\\"\\n checkFileExists(basepath, sfv_file, yes)\\n createSfv(basepath, sfv_file)\\n if filetree is True or default is True:\\n csvtree_file = f\\\"{basepath.name}_file_tree.csv\\\"\\n jsontree_file = f\\\"{basepath.name}_file_tree.json\\\"\\n checkFileExists(basepath, jsontree_file, yes)\\n checkFileExists(basepath, csvtree_file, yes)\\n createFileTree(basepath, jsontree_file, csvtree_file)\\n if meta is True or default is True:\\n metadata_file = f\\\"{basepath.name}_metadata.json\\\"\\n checkFileExists(basepath, metadata_file, yes)\\n createMetadata(basepath, metadata_file)\\n if newmeta is True:\\n createNewMetadata(basepath)\\n filesCache.cache_clear()\\n getFileInfo.cache_clear()\\n killTika()\\n\\n stop_time = time()\\n print(f\\\"Finished in {round(stop_time-start_time, 2)} seconds\\\")\",\n \"def alternative_miner(filepath, minFrequency):\\n\\t# TODO: either second implementation of the apriori algorithm or implementation of the depth first search algorithm\\n\\tprint(\\\"Not implemented\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62167066","0.55113137","0.545679","0.5249099","0.52270174","0.52258456","0.5218894","0.5173524","0.5060165","0.50510776","0.5016965","0.49667448","0.49320337","0.4899114","0.4883986","0.48228544","0.48040769","0.47905743","0.47506174","0.47441763","0.4716718","0.47160745","0.4706927","0.46956733","0.46790585","0.465785","0.46558952","0.46534717","0.46416453","0.46406412","0.46136597","0.46130243","0.4610868","0.45938537","0.45828822","0.4569681","0.455881","0.45567986","0.4556374","0.4551027","0.45441532","0.45020774","0.44979846","0.44855568","0.4473704","0.44673455","0.4461995","0.44575265","0.44520783","0.44495028","0.44495028","0.44429806","0.44333014","0.44278833","0.4425821","0.4424345","0.44134971","0.44108123","0.44038194","0.44031018","0.43980005","0.4397599","0.43951184","0.4383675","0.43793806","0.43784696","0.43733838","0.43685934","0.4366453","0.43658513","0.4365475","0.43576995","0.4357219","0.43570894","0.43532112","0.4349331","0.43458667","0.43457848","0.43455145","0.43371996","0.43286374","0.43252364","0.43246529","0.4321008","0.432067","0.431941","0.43159407","0.43092078","0.4300379","0.4299996","0.42963257","0.42957243","0.4295624","0.42952257","0.42952204","0.4287202","0.42865857","0.4286579","0.42809093","0.42791888"],"string":"[\n \"0.62167066\",\n \"0.55113137\",\n \"0.545679\",\n \"0.5249099\",\n \"0.52270174\",\n \"0.52258456\",\n \"0.5218894\",\n \"0.5173524\",\n \"0.5060165\",\n \"0.50510776\",\n \"0.5016965\",\n \"0.49667448\",\n \"0.49320337\",\n \"0.4899114\",\n \"0.4883986\",\n \"0.48228544\",\n \"0.48040769\",\n \"0.47905743\",\n \"0.47506174\",\n \"0.47441763\",\n \"0.4716718\",\n \"0.47160745\",\n \"0.4706927\",\n \"0.46956733\",\n \"0.46790585\",\n \"0.465785\",\n \"0.46558952\",\n \"0.46534717\",\n \"0.46416453\",\n \"0.46406412\",\n \"0.46136597\",\n \"0.46130243\",\n \"0.4610868\",\n \"0.45938537\",\n \"0.45828822\",\n \"0.4569681\",\n \"0.455881\",\n \"0.45567986\",\n \"0.4556374\",\n \"0.4551027\",\n \"0.45441532\",\n \"0.45020774\",\n \"0.44979846\",\n \"0.44855568\",\n \"0.4473704\",\n \"0.44673455\",\n \"0.4461995\",\n \"0.44575265\",\n \"0.44520783\",\n \"0.44495028\",\n \"0.44495028\",\n \"0.44429806\",\n \"0.44333014\",\n \"0.44278833\",\n \"0.4425821\",\n \"0.4424345\",\n \"0.44134971\",\n \"0.44108123\",\n \"0.44038194\",\n \"0.44031018\",\n \"0.43980005\",\n \"0.4397599\",\n \"0.43951184\",\n \"0.4383675\",\n \"0.43793806\",\n \"0.43784696\",\n \"0.43733838\",\n \"0.43685934\",\n \"0.4366453\",\n \"0.43658513\",\n \"0.4365475\",\n \"0.43576995\",\n \"0.4357219\",\n \"0.43570894\",\n \"0.43532112\",\n \"0.4349331\",\n \"0.43458667\",\n \"0.43457848\",\n \"0.43455145\",\n \"0.43371996\",\n \"0.43286374\",\n \"0.43252364\",\n \"0.43246529\",\n \"0.4321008\",\n \"0.432067\",\n \"0.431941\",\n \"0.43159407\",\n \"0.43092078\",\n \"0.4300379\",\n \"0.4299996\",\n \"0.42963257\",\n \"0.42957243\",\n \"0.4295624\",\n \"0.42952257\",\n \"0.42952204\",\n \"0.4287202\",\n \"0.42865857\",\n \"0.4286579\",\n \"0.42809093\",\n \"0.42791888\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5894984"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":76295,"cells":{"query":{"kind":"string","value":"Uses recursive DFS to write the overrides from a weigthed, assigned file tree"},"document":{"kind":"string","value":"def _write_overrides(\n self, node, parent=None, parent_packmode=None, path_parts=tuple(), root=None\n ):\n if root is None:\n root = node\n if (parent is root) or (\n parent_packmode and node[\"packmode\"] != parent_packmode\n ):\n self.overrides[str(PurePath(*path_parts))] = node[\"packmode\"]\n for key, child in node[\"children\"].items():\n self._write_overrides(\n node=child,\n parent=node,\n parent_packmode=node[\"packmode\"],\n path_parts=path_parts + (key,),\n root=root,\n )"},"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 _mutate_file(self, node, visited = set([])):\n for ch in self._get_children(node):\n\n if ch not in visited:\n visited.add(ch)\n\n try:\n self._mutate_node(ch)\n except Exception as e:\n print(e)\n\n # Recursion is a bitch\n self._mutate_file(ch, visited)","def _walk(self, level=0):\n l_dict = self.list_all()\n indent = level * \" \"\n for node in l_dict[\"nodes\"]:\n print(indent + \"node\", node)\n for group in l_dict[\"groups\"]:\n print(indent + \"group: \", group)\n with self.open(group) as hdf_group:\n hdf_group._walk(level=level + 1)","def walkthrough(software_map):\n\n for i in software_map:\n\n if not i[\"is_file\"]:\n\n # for each directory: make a index.md\n dname = \"./docs/\" + i[\"name\"]\n index = \"./docs/\" + i[\"name\"] + \"/index.md\"\n print(index)\n os.mkdir(dname)\n\n with open(index, \"w+\") as f:\n\n children = i[\"children\"]\n\n # list files\n f.write(\"Files:\\n\\n\")\n for i in children:\n if i[\"is_file\"]:\n\n fname = i[\"name\"]\n fext = fname.split(\".\")\n if len(fext) == 2:\n fext = fext[1]\n else:\n fext = \"none\"\n # for each file, note name and extension\n f.write(fname + \" : \" + fext + \"\\n\")\n\n # list subdirectories\n f.write(\"\\nSubdirectories:\\n\\n\")\n for i in children:\n if not i[\"is_file\"]:\n\n dirname = i[\"name\"]\n\n # note the number of files and subdirs in it\n num_files, num_dirs = 0, 0\n for child in i[\"children\"]:\n if child[\"is_file\"]:\n num_files += 1\n elif not child[\"is_file\"]:\n num_dirs += 1\n\n # note down name and numbers for each dir\n f.write(dirname + \" : \" + str(num_files) + \" files, \" +\n str(num_dirs) + \" directories\\n\")\n\n # goto subdir\n if len(i[\"children\"]) > 0:\n walkthrough(i[\"children\"])","def save_node(self):\n # save node in path2node\n if self.full_path in self.file.path2node:\n print \"** Error, created node with path twice:\\n%s\" % self.full_path\n traceback.print_stack()\n sys.exit(1)\n self.file.path2node[self.full_path] = self \n # save node in id_lookups\n id = self.sdef['id']\n ns = self.sdef['ns']\n type = self.sdef['type']\n custom = 'custom' in self.sdef and self.sdef['custom']\n if self.parent is None and self.sdef['df'] and not custom:\n # structure (not custom) created at top level, save in id_lookups\n if id not in self.file.id_lookups[ns]:\n print \"** Error: Unable to find id '%s' in id_lookups when saving node\" % id\n traceback.print_stack()\n sys.exit(1)\n if self.path not in self.file.id_lookups[ns][id]:\n print (\"** Error: Unable to find path '%s' in id_lookups when\"\n \" saving node %s\") % (self.path, id)\n print \"self.sdef['df'] is:\"\n pp.pprint (self.sdef['df'])\n traceback.print_stack()\n sys.exit(1)\n self.file.id_lookups[ns][id][self.path]['created'].append(self)\n # save node in all_nodes, either at top level (if no parent) or inside\n # mstats structure of parent node\n if self.parent is None:\n if self.path in self.file.all_nodes:\n self.file.all_nodes[self.path].append(self)\n else:\n self.file.all_nodes[self.path] = [self, ]\n else:\n if id not in self.parent.mstats:\n if custom:\n # custom node created, add id to mstats of parent\n self.parent.mstats[id] = { 'df': {}, 'type':type, 'ns': ns,\n 'created': [ self, ], 'qty':'?' }\n else:\n print \"** Error: Unable to find key '%s' in parent mstats\" % id\n print \"self.parent.mstats is\"\n pp.pprint (self.parent.mstats)\n traceback.print_stack()\n sys.exit(1)\n else: \n # append node to parent created mstats \n self.parent.mstats[id]['created'].append(self)","def test_modifying_nested_files(self):\n nested_file = os.path.join(REPO_PATH, 'subdir/nested.txt')\n with open(nested_file, 'a') as nested:\n nested.write('nested file stuff')\n\n self.result = self.runRegress(\n ['../resources/modifying_nested_files.sh', 'subdir/nested.txt'],\n 'all_bad', py_test=False)\n\n open(nested_file, 'w').close()","def create_rooted_trees_from_dir(paths, fout, outgroup):\n #pdb.set_trace()\n fout = open(fout, 'w')\n for count, path in enumerate(paths):\n base_path, tree_file_name = os.path.split(path)\n #pdb.set_trace()\n fin = open(path)\n for tree in fin:\n tree = tree.strip()\n tree = Tree(tree)\n tree.set_outgroup(outgroup)\n newick = tree.write(format=5) + '\\n'\n fout.write(newick)\n print count+1\n fout.close()","def _build_file_tree(self):\n # Build file tree with packmode and weigth info (# of file in the packmode)\n root = {\"packmode\": None, \"weight\": None, \"children\": {}}\n for filepath, packmode in self.override_packmode_map.items():\n node = root\n for part in filepath:\n node = node[\"children\"].setdefault(\n part, {\"packmode\": None, \"weight\": None, \"children\": {}}\n )\n node[\"weight\"] = 1\n node[\"packmode\"] = packmode\n return root","def filetree(self) -> P:\n ...","def update_rels(fl_list, tmp_loc, dict_1):\n old_files = natsort.natsorted([i for i in dict_1.keys()])\n path = f'{output_path}/ppt'\n for i in fl_list:\n root, tree = gen_tree(f'{path}/{i}')\n for relation in root:\n attrib = relation.attrib\n if attrib.get('Target')[3:] in old_files:\n relation.set('Target', f\"../{dict_1[attrib.get('Target')[3:]]}\")\n tree.write(f'{path}/{i}', pretty_print=True, xml_declaration=True, encoding='UTF-8', standalone=True)\n return","def _dfs_assign(self, filetree):\n stack = [filetree]\n while stack:\n node = stack.pop()\n if isinstance(node, tuple) and node[0][\"packmode\"] is None:\n # all children have been seen already, assing packmode\n node = node[0] # unpack the actual node\n weights = defaultdict(int)\n for child in node[\"children\"].values():\n weights[child[\"packmode\"]] += child[\"weight\"]\n packmode, weight = max(weights.items(), key=lambda x: x[1])\n node[\"weight\"] = weight\n node[\"packmode\"] = packmode\n elif node[\"children\"]:\n # schedule that node for computation\n stack.append((node,))\n # visit all children first\n for child in node[\"children\"].values():\n stack.append(child)","def walk(self, path):\n # strip trailing slashes, they are not needed\n path = path.rstrip(os.path.sep)\n\n # check if a weight has been provided for this argument\n weight_adjust, path = check_level(path)\n\n if os.path.isfile(path):\n if self.args.stagger_paths:\n weight_adjust = weight_adjust + self.stagger\n new_file = FileObj(path, self.args, self.db,\n weight_adjust=weight_adjust)\n if self.args.stagger_paths:\n self.stagger = self.stagger + new_file.depth\n self.contents[path] = new_file\n elif issocket(path):\n print('WARNING: Skipping a socket ' + path, file=sys.stderr)\n elif os.path.isdir(path):\n if self.args.stagger_paths:\n weight_adjust = weight_adjust + self.stagger\n top_dir_entry = DirObj(path, self.args, weight_adjust)\n self.contents[path] = top_dir_entry\n for dir_name, _, file_list in os.walk(path, topdown=False):\n # we do not walk into or add names from our ignore list.\n # We wont delete them if they are leaf nodes and we wont\n # count them towards parent nodes.\n if os.path.basename(dir_name) in DELETE_DIR_LIST:\n continue\n\n dir_entry = top_dir_entry.place_dir(\n dir_name, weight_adjust)\n if dir_entry is None:\n continue\n\n for fname in file_list:\n pname = os.path.join(dir_entry.pathname, fname)\n if issocket(pname):\n print('WARNING: Skipping a socket ' +\n pname, file=sys.stderr)\n elif os.path.basename(fname) not in DELETE_FILE_LIST:\n new_file = FileObj(fname, self.args, self.db,\n parent=dir_entry,\n weight_adjust=weight_adjust)\n if new_file.bytes == 0 and not self.args.keep_empty_files:\n new_file.to_delete = True\n dir_entry.files[fname] = new_file\n\n if self.args.stagger_paths:\n self.stagger = self.stagger + top_dir_entry.max_depth()\n else:\n print(\"\\nFATAL ERROR: dont know what this is: \" +\n path, file=sys.stderr)\n sys.exit()","def get_desired_depth(file_name, tree, desired_depth):\n node_keys = []\n get_nodes_at_depth(tree.root, desired_depth, node_keys)\n generate_file(file_name, node_keys)\n print(\"File '\" + file_name + \"' generated with keys at depth: :\", desired_depth)","def traverse(self, filelist, depth=0):\n if depth > 10:\n return ['depth > 10']\n level = {}\n for entry in (path for path in self.connection.nlst() if path not in ('.', '..')):\n try:\n self.connection.cwd(entry)\n level[entry] = self.traverse(filelist, depth+1)\n self.connection.cwd('..')\n except ftplib.error_perm:\n level[entry] = None\n return level","def updateTree(self):\n self.reset()\n self.resetTree() \n self.read()","def createExtnNodes(self):\n for parent, dirs, files in os.walk(self.destndir):\n for fname in files:\n filename = os.path.join(parent, fname)\n if os.path.isfile(filename):\n direntry=parent\n #direntry=parent.replace(self.destndir,'',len(self.destndir))\n #direntry = os.path.basename(os.path.abspath(parent))\n self.appendSrcType(direntry, fname)","def writeGraph2File(self, file, genGraph=1, isRootNode=0, rootNodeName = \"rootNode\", \\\r\n indent=\" \", genConstraints = 0, fileName = '', genGGcode = 0, parentName=\"self\", \\\r\n genImports = 0, depth = 1, nodesToGenList = [] ):\r\n\r\n # generate code for the nodes...\r\n counter =0\r\n if( not nodesToGenList ):\r\n for nodetype in self.nodeTypes:\t\t\t\t\t\t# iterate on all the node types...\r\n for node in self.listNodes[nodetype]:\t\t\t\t\t# Iterate on all the nodes of each type\r\n node.genAttributesCode(file, genGraph, None, isRootNode, rootNodeName, indent, genConstraints, 1, genGGcode, parentName, genImports, depth + 1 )\r\n if self.isSubclass(node, 'ASG'):\t\t\t\t\t# if it is a subclass of ASG, ws should include the file generated (hierarchical modeling)\r\n newFile = fileName+str(counter)\r\n file.write(indent+'exec \"from '+newFile+' import '+newFile+'\\\\n\" in self.__dict__, self.__dict__\\n')\r\n file.write(indent+'self.'+newFile+'(self, self.obj'+str(node.objectNumber)+') \\n\\n')\r\n counter = counter + 1\r\n else:\r\n for node in nodesToGenList:\t\t\t\t\r\n node.genAttributesCode(file, genGraph, None, isRootNode, rootNodeName, indent, genConstraints, 1, genGGcode, parentName, genImports, depth + 1 )\r\n if self.isSubclass(node, 'ASG'):\t\t\t\t\t# if it is a subclass of ASG, ws should include the file generated (hierarchical modeling)\r\n newFile = fileName+str(counter)\r\n file.write(indent+'exec \"from '+newFile+' import '+newFile+'\\\\n\" in self.__dict__, self.__dict__\\n')\r\n file.write(indent+'self.'+newFile+'(self, self.obj'+str(node.objectNumber)+') \\n\\n')\r\n counter = counter + 1\r\n \r\n \r\n # if fileName has a value, we are saving a model, we must generate a function to hold the connections...\r\n if fileName != '':\r\n # if we are not dealing with a hierarchical model, an extra method is not needed..\r\n hierarchical = self.isHierarchical()\r\n if hierarchical:\r\n file.write('\\ndef '+fileName+'_connections(self, rootNode):\\n')\r\n\r\n\r\n #-------- Modified by Ximeng Sun / Apr 9,2005 for large conn nums --------\r\n file.write('\\n')\r\n writed = 0\r\n # generate code for the connections...\r\n if( not nodesToGenList ):\r\n for nodetype in self.nodeTypes:\r\n for node in self.listNodes[nodetype]:\r\n if isRootNode: \r\n if(node.__dict__.has_key('name')):\r\n debugName = ' named ' + node.name.toString() + '\\n'\r\n else:\r\n debugName = ' of type ' + node.__class__.__name__ + '\\n'\r\n file.write(indent+'# Connections for obj'+str(node.objectNumber)\r\n +' (graphObject_: '+node.graphObject_.tag + ')' + debugName)\r\n file.write(indent+'self.drawConnections(\\n')\r\n res = node.genConnectionsCode(file, genGraph, isRootNode, \r\n indent, 1, writed)\r\n if isRootNode: \r\n file.write(' )\\n')\r\n else:\r\n for node in nodesToGenList:\r\n if isRootNode: file.write(indent+'self.drawConnections(')\r\n res = node.genConnectionsCode(file, genGraph, isRootNode, indent, 1, \r\n writed, nodesToGenList = nodesToGenList)\r\n if isRootNode: file.write(' )\\n')\r\n file.write('\\n')\r\n #------------ End of modification by Ximeng Sun / Apr 9,2005 -------------\r\n \r\n \r\n # if rootNode and I'm generating a function (filename != '')\r\n # then call subModel's functions for connections...\r\n if isRootNode and fileName != '': # if main model\r\n counter = 0\r\n if( not nodesToGenList ):\r\n for nodetype in self.nodeTypes: # iterate, to search for all submodels\r\n for node in self.listNodes[nodetype]:\r\n if self.isSubclass(node, 'ASG'): # found a submodel\r\n file.write(indent+'self.'+fileName+str(counter)+'_connections( self, self.obj'+str(node.objectNumber)+')\\n')\r\n writed = 1\r\n counter = counter + 1\r\n else:\r\n for node in nodesToGenList:\r\n if self.isSubclass(node, 'ASG'): # found a submodel\r\n file.write(indent+'self.'+fileName+str(counter)+'_connections( self, self.obj'+str(node.objectNumber)+')\\n')\r\n writed = 1\r\n counter = counter + 1\r\n \r\n \r\n if fileName != '' and (not writed) and hierarchical: # we must write 'pass', because nothing has been writed in the function!!\r\n file.write(indent+'pass\\n')","def old_create_dir_struct(self, create_first_rev_folder=\"True\"):\n # | - create_dir_struct\n for job in self.job_var_lst:\n if create_first_rev_folder == \"True\":\n path = self.var_lst_to_path(job) + \"_1\"\n elif create_first_rev_folder == \"False\":\n path = self.var_lst_to_path(job)\n\n path = self.root_dir + \"/\" + path\n\n if os.path.exists(path):\n mess = \"Path already exists: \" + str(path)\n print(mess)\n\n elif not os.path.exists(path):\n os.makedirs(path)\n\n # | - Creating Variable Text Files Through Directoy Structure\n for job in self.job_var_lst:\n path = self.var_lst_to_path(job)\n path = self.root_dir + \"/\" + path\n\n file_name = path + \"job_dir_level\"\n with open(file_name, \"w\") as fle:\n fle.write(\"\\n\")\n\n for root, dirs, files in os.walk(self.root_dir + \"/data/\"):\n if \"job_dir_level\" in files:\n continue\n\n else:\n prop_lst = []\n for folder in dirs:\n tmp = self.sep.join(folder.split(self.sep)[1:])\n\n prop = self.__replace_p_for_per__(tmp)\n prop = self.__replace_negative_for_n__(prop)\n prop_lst.append(prop)\n\n for key, value in self.level_entries.items():\n if set(prop_lst) == set(map(str, value)):\n\n file_name = root + \"/properties.txt\"\n with open(file_name, \"w\") as fle:\n fle.write(key + \"\\n\")\n\n # f = open(root + \"/properties.txt\", \"w\")\n # f.write(key + \"\\n\")\n # f.close()\n # __|\n\n # self.__create_dir_structure_file__()\n\n # | - folders_exist attribute should be True from now on\n file_name = self.root_dir + \"/jobs_bin/.folders_exist\"\n with open(file_name, \"w\") as fle:\n fle.write(\"\\n\")\n\n self.folders_exist = self.__folders_exist__(True)\n # __|\n\n # __|","def _update_subfiles(self) -> None:\n\t\t# Clear list of subfiles\n\t\tself.subfiles.clear()\n\t\t# Iterate over Nodes\n\t\tfor node in self.nodes:\n\t\t\tfor file in node.get_subfiles():\n\t\t\t\tself.subfiles.add(\"{}/{}\".format(self.xml_dir, file))\n\t\t# Iterate over SubNodes\n\t\tfor subnode in self.subnodes:\n\t\t\tfor file in subnode.filenames:\n\t\t\t\tself.subfiles.add(\"{}/{}\".format(self.xml_dir, file))","def save_filter_tree(self,root,good_nodes):\n date = str(datetime.now())[5:10]\n filename = \"./log/filter_tree_\" + date\n if os.path.isfile(filename):\n os.remove(filename)\n if good_nodes == []:\n with open(filename,\"a+\") as inp:\n inp.write(\"root\\n\")\n else:\n for node in good_nodes:\n node.save_node(filename)\n with open(filename,\"a+\") as inp:\n inp.write(\"root\\n\")\n \n parent = root\n curr_node = root.children[0]\n while True:\n curr_node.save_node(filename)\n if curr_node.children == []:\n while parent.next_child(curr_node) is None:\n if parent == root and parent.next_child(curr_node) is None:\n return\n curr_node = parent\n parent = curr_node.parent\n curr_node = parent.next_child(curr_node)\n else:\n parent = curr_node\n curr_node = parent.children[0]","def recurse(path):\n for dirpath, dirnames, filenames in os.walk(path):\n for filename in filenames:\n if filename.endswith('.robot'):\n filepath = os.path.join(dirpath, filename)\n reformat(filepath)","def create_tree(outFile, tree, path='/'):\n for key, foo in tree.list():\n if outFile.has_node(path, key):\n logging.debug('Path already found:', path, key)\n continue\n logging.debug('Creating group:', path, key)\n outFile.create_group(path, key, key)\n dest = path + key + '/'\n if outFile.has_node(dest):\n continue\n create_tree(outFile, tree.child(key), dest)","def __walk_tree(self):\n for root, dirnames, files in os.walk(self.path, topdown=True):\n self.dirCount += 1\n # Create a tuple with the file size, the file name and the files inode (for tracking hard links).\n files = [\n (os.lstat(os.path.join(root, fi)).st_size, os.path.join(root, fi), os.lstat(os.path.join(root, fi)).st_ino) for fi\n in files if (os.lstat(os.path.join(root, fi)).st_size > self.size)]\n self.fileList.extend(files)\n if len(self.excludeList) > 0:\n dirnames[:] = [dir for dir in dirnames if dir not in self.excludeList]\n if not self.cross_mount_points:\n dirnames[:] = [dir for dir in dirnames if not os.path.ismount(os.path.join(root, dir))]","def makeTree(node,baseName,baseAddress,nodes,parentNode,vars,isGenerated):\n \n if (isGenerated == None or isGenerated == False) and node.get('generate') is not None and node.get('generate') == 'true':\n generateSize = parseInt(node.get('generate_size'))\n generateAddressStep = parseInt(node.get('generate_address_step'))\n generateIdxVar = node.get('generate_idx_var')\n for i in range(0, generateSize):\n vars[generateIdxVar] = i\n makeTree(node, baseName, baseAddress + generateAddressStep * i, nodes, parentNode, vars, True)\n return\n newNode = Node()\n name = baseName\n if baseName != '': name += '.'\n if node.get('id') is not None:\n name += node.get('id')\n name = substituteVars(name, vars)\n newNode.name = name\n if node.get('description') is not None:\n newNode.description = node.get('description')\n address = baseAddress\n if node.get('address') is not None:\n address = baseAddress + parseInt(node.get('address'))\n newNode.address = address\n newNode.real_address = (address<<2)+0x64000000\n newNode.permission = node.get('permission')\n newNode.mask = parseInt(node.get('mask'))\n newNode.isModule = node.get('fw_is_module') is not None and node.get('fw_is_module') == 'true'\n if node.get('sw_monitor_warn_min_threshold') is not None:\n newNode.warn_min_value = node.get('sw_monitor_warn_min_threshold') \n if node.get('sw_monitor_error_min_threshold') is not None:\n newNode.error_min_value = node.get('sw_monitor_error_min_threshold') \n nodes[name] = newNode\n if parentNode is not None:\n parentNode.addChild(newNode)\n newNode.parent = parentNode\n newNode.level = parentNode.level+1\n for child in node:\n makeTree(child,name,address,nodes,newNode,vars,False)","def postOrderMerge(self):\n\n seen = {}\n roots = self.roots()\n\n # Run the merge starting at each root. Note that seen\n # is presisted throughout.\n for root in roots:\n self.postOrderMergeHelper(root, seen)\n\n # Clean out any dead nodes\n self.clean()","def __create_dir_structure_file__(self):\n # | - __create_dir_structure_file__\n\n dir_structure_data = {}\n dir_structure_data[\"tree_level_labels\"] = self.tree_level_labels\n dir_structure_data[\"level_entries_dict\"] = self.level_entries_list\n # TEMP\n dir_structure_data[\"skip_dirs\"] = self.skip_dirs_lst\n\n fle_name = os.path.join(\n self.root_dir,\n self.working_dir,\n \"jobs_bin/dir_structure.json\",\n )\n\n with open(fle_name, \"w\") as fle:\n json.dump(dir_structure_data, fle, indent=2)\n # __|","def test_checkForOldParents(self):\n f = open(\"Output.txt\", \"a+\")\n fam: Dict = {'F23':\n {'fam': 'F23', 'MARR': '14 FEB 1980', 'HUSB': 'I01', 'WIFE': 'I07',\n 'CHIL': ['I19', 'I26', 'I30']},\n 'F16': {'fam': 'F16', 'MARR': '12 DEC 2007'}}\n fam2: Dict = {'F23': {'fam': 'F23', 'MARR': '14 FEB 1980', 'HUSB': 'I01', 'WIFE': 'I07', 'CHIL': ['I19']}}\n\n ind1: Dict = {'I01': {'id': 'I01', 'name': 'Joe /Smith/', 'BIRT': '15 JUL 1900', 'sex': 'M', 'family': 'F23',\n 'DEAT': '31 DEC 2013'},\n 'I07': {'id': 'I07', 'name': 'Jennifer /Smith/', 'BIRT': '23 SEP 1902', 'sex': 'F',\n 'family': 'F23',\n 'DEAT': '31 DEC 2013'},\n 'I19': {'id': 'I19', 'name': 'Dick /Smith/', 'BIRT': '13 FEB 1999', 'sex': 'M', 'family': 'F23',\n 'DEAT': '31 DEC 2013'}}\n\n ind2: Dict = {'I01': {'id': 'I01', 'name': 'Joe /Smith/', 'BIRT': '15 JUL 1960', 'sex': 'M', 'family': 'F23',\n 'DEAT': '31 DEC 2013'},\n 'I07': {'id': 'I07', 'name': 'Jennifer /Smith/', 'BIRT': '23 SEP 1960', 'sex': 'F',\n 'family': 'F23'},\n 'I19': {'id': 'I19', 'name': 'Dick /Smith/', 'BIRT': '13 FEB 1981', 'sex': 'M', 'family': 'F23'},\n 'I26': {'id': 'I26', 'name': 'Jane /Smith/', 'BIRT': '13 FEB 1981', 'sex': 'F', 'family': 'F23'},\n 'I30': {'id': 'I30', 'name': 'Mary /Test/', 'BIRT': '13 FEB 1981', 'sex': 'F', 'family': 'F23'},\n 'I32': {'id': 'I32', 'name': 'Nick /Tary/', 'BIRT': '13 FEB 1981', 'sex': 'M', 'family': 'F23'},\n 'I44': {'id': 'I44', 'name': 'Cersi /Lanister/', 'BIRT': '13 FEB 1981', 'sex': 'F',\n 'family': 'F23'}}\n\n self.assertTrue(us.checkForOldParents(fam, ind2, f))\n self.assertFalse(us.checkForOldParents(fam2, ind1, f))","def convert_treebank(input_dir, output_dir, strategy, subtask):\n\n for f in input_dir.iterdir():\n with open(f, \"r\") as json_file:\n docs = json.load(json_file)\n trees = \"\"\n for doc in docs[\"docs\"]:\n for sent in doc[\"sents\"]:\n graph = sent[\"graph\"]\n if strategy == \"start\":\n tree = traverse_graph_start(graph)\n elif strategy == \"start-without-pos\":\n tree = traverse_graph_start_without_pos(graph)\n elif strategy == \"end\":\n tree = traverse_graph_end(graph)\n elif strategy == \"end-extra-node\":\n tree = traverse_graph_end_extra_node(graph)\n elif strategy == \"start-end-extra-node\":\n tree = traverse_graph_start_end_extra_node(graph)\n elif strategy == \"start-end-extra-node-heuristic\":\n tree = traverse_graph_start_end_extra_node_heuristic(graph) \n if subtask:\n tree = subtask_prune(tree)\n tree_string = get_string(tree)\n trees += tree_string + \"\\n\"\n with open(output_dir.joinpath(f.name).with_suffix(\".txt\"), \"w+\") as tree_files:\n tree_files.write(trees)","def write_file_tree(node, header_data, path=None, levels=0):\n\n if path is not None:\n name = os.path.join(path, node.name)\n else:\n name = node.name\n\n if isinstance(node, pygit2.Blob):\n return [write_blob(node, header_data, path=path, levels=levels)]\n\n if isinstance(node, pygit2.Tree):\n subnodes = list(\n itertools.chain.from_iterable(\n write_file_tree(\n subnode, header_data, path=name, levels=levels + 1\n )\n for subnode in node\n )\n )\n return subnodes\n\n return []","def file_walker(root,**kwargs):\n\n # Get our keyword argunents, and do some initialization.\n max_depth=kwargs.get('depth',None)\n if max_depth==None:\n max_depth=sys.maxsize # I don't think we'll hit this limit in practice.\n follow_links=kwargs.get('follow_links',True)\n prune=compile_filename_patterns(kwargs.get('prune',[]))\n ignore=compile_filename_patterns(kwargs.get('ignore',[]))\n report_dirs=kwargs.get('report_dirs',False)\n if report_dirs not in (False,True,'first','last'):\n raise ValueError(\"report_dirs=%r is not one of False, True, 'first', or 'last'.\"%(report_dirs,))\n stack=[(0,root)] # Prime our stack with root (at depth 0).\n been_there=set([os.path.abspath(os.path.realpath(root))])\n dir_stack=[] # Stack of paths we're yielding after exhausting those directories.\n\n while stack:\n depth,path=stack.pop()\n if report_dirs in (True,'first'):\n yield path+os.sep\n elif report_dirs=='last':\n dir_stack.append(path+os.sep)\n flist=os.listdir(path)\n flist.sort()\n dlist=[]\n # First, let the caller iterate over these filenames.\n for fn in flist:\n p=os.path.join(path,fn)\n if os.path.isdir(p):\n # Just add this to this path's list of directories for now.\n dlist.insert(0,fn)\n continue\n pat,mat=first_match(fn,ignore)\n if not pat:\n yield p\n # Don't dig deeper than we've been told to.\n if depth<max_depth:\n # Now, let's deal with the directories we found.\n for fn in dlist:\n p=os.path.join(path,fn)\n # We might need to stack this path for our fake recursion.\n if os.path.islink(p) and not follow_links:\n # Nope. We're not following symlinks.\n continue\n rp=os.path.abspath(os.path.realpath(p))\n if rp in been_there:\n # Nope. We've already seen this path (and possibly processed it).\n continue\n m=None\n pat,mat=first_match(fn,prune)\n if pat:\n # Nope. This directory matches one of the prune patterns.\n continue\n # We have a keeper! Record the path and push it onto the stack.\n been_there.add(rp)\n stack.append((depth+1,p))\n while dir_stack:\n yield dir_stack.pop()","def update_tip_names(tree, taxdict):\n\n list_nodes = []\n uniprot_mapping = pd.DataFrame(columns=['taxid', 'name', 'uniprot'])\n\n counter = 0\n for node in tree.traverse(\"postorder\"):\n current_name = node.name\n\n if 'NMR' in current_name:\n new_name = \"Heterocephalus_glaber\"\n node.name = new_name\n list_nodes.append(node.name)\n taxid = \"NA\" \n uniprot_mapping.loc[counter] = (taxid, new_name, \"UP000006813\")\n counter += 1\n\n elif 'Nfurzer' in current_name:\n new_name = \"Nothobranchius_furzeri\"\n node.name = new_name\n list_nodes.append(node.name)\n taxid = \"NA\"\n uniprot_mapping.loc[counter] = (taxid, new_name, new_name)\n counter += 1\n\n elif 'TAX' in current_name:\n taxid = current_name[3:].split('x')[0]\n new_name = taxdict.get(taxid, taxid) \n node.name = new_name \n list_nodes.append(node.name)\n unip = get_uniprot(taxid, accession)\n uniprot_mapping.loc[counter] = (taxid, new_name, unip)\n counter += 1\n\n\n \n tree.write(outfile=\"../../data/tree/tree.nw\")\n\n nodes_df = pd.DataFrame(list_nodes)\n nodes_df.to_csv(\"../../data/tree/tree_list_nodes.txt\", index=False, header=False)\n\n uniprot_mapping.to_csv(\"../../data/tree/tree_uniprot.txt\", sep='\\t', index=False, header=True)\n\n return tree, list_nodes","def __gen_hierarchy_file(self, layer):\n paula_id = '{}.{}.{}_{}'.format(layer, self.corpus_name, self.name,\n layer)\n self.paulamap['hierarchy'][layer] = paula_id\n E, tree = gen_paula_etree(paula_id)\n\n dominance_edges = select_edges_by(\n self.dg, layer=layer, edge_type=EdgeTypes.dominance_relation,\n data=True)\n span_edges = select_edges_by(\n self.dg, layer=layer, edge_type=EdgeTypes.spanning_relation,\n data=True)\n dominance_dict = defaultdict(lambda: defaultdict(str))\n for source_id, target_id, edge_attrs in dominance_edges:\n if source_id != layer+':root_node':\n dominance_dict[source_id][target_id] = edge_attrs\n\n # in PAULA XML, token spans are also part of the hierarchy\n for source_id, target_id, edge_attrs in span_edges:\n if istoken(self.dg, target_id):\n dominance_dict[source_id][target_id] = edge_attrs\n\n # NOTE: we don't add a base file here, because the nodes could be\n # tokens or structural nodes\n slist = E('structList', {'type': layer})\n for source_id in dominance_dict:\n struct = E('struct',\n {'id': str(source_id)})\n if self.human_readable:\n struct.append(Comment(self.dg.node[source_id].get('label')))\n\n for target_id in dominance_dict[source_id]:\n if istoken(self.dg, target_id):\n href = '{}.xml#{}'.format(self.paulamap['tokenization'],\n target_id)\n else:\n href = '#{}'.format(target_id)\n\n rel = E(\n 'rel',\n {'id': 'rel_{}_{}'.format(source_id, target_id),\n 'type': dominance_dict[source_id][target_id]['edge_type'],\n XLINKHREF: href})\n struct.append(rel)\n if self.human_readable:\n struct.append(\n Comment(self.dg.node[target_id].get('label')))\n slist.append(struct)\n tree.append(slist)\n self.files[paula_id] = tree\n self.file2dtd[paula_id] = PaulaDTDs.struct\n return paula_id","def test_scan_recursive(self):\n self.run_scan(self.tempdir, self.root_fcount + self.nest_fcount + 1)","def _set_level_depth(self, optobj):\n has_relationship = optobj is not None and 'relationship' in optobj.optional_attrs\n\n def _init_level(rec):\n if rec.level is None:\n if rec.parents:\n rec.level = min(_init_level(rec) for rec in rec.parents) + 1\n else:\n rec.level = 0\n return rec.level\n\n def _init_depth(rec):\n if rec.depth is None:\n if rec.parents:\n rec.depth = max(_init_depth(rec) for rec in rec.parents) + 1\n else:\n rec.depth = 0\n return rec.depth\n\n def _init_reldepth(rec):\n if not hasattr(rec, 'reldepth'):\n up_terms = rec.get_goterms_upper()\n if up_terms:\n rec.reldepth = max(_init_reldepth(rec) for rec in up_terms) + 1\n else:\n rec.reldepth = 0\n return rec.reldepth\n\n for rec in self.values():\n\n # Add invert relationships\n if has_relationship:\n if rec.depth is None:\n _init_reldepth(rec)\n\n # print(\"BBBBBBBBBBB1\", rec.id, rec.relationship)\n #for (typedef, terms) in rec.relationship.items():\n # invert_typedef = self.typedefs[typedef].inverse_of\n # # print(\"BBBBBBBBBBB2 {} ({}) ({}) ({})\".format(\n # # rec.id, rec.relationship, typedef, invert_typedef))\n # if invert_typedef:\n # # Add inverted relationship\n # for term in terms:\n # if not hasattr(term, 'relationship'):\n # term.relationship = defaultdict(set)\n # term.relationship[invert_typedef].add(rec)\n # print(\"BBBBBBBBBBB3\", rec.id, rec.relationship)\n\n if rec.level is None:\n _init_level(rec)\n\n if rec.depth is None:\n _init_depth(rec)","def write(self,data): \n if not os.path.exists(self.output_dir):\n os.makedirs(self.output_dir)\n\n # We will store these in a separate file and link them to the level2s\n fname = data.filename.split('/')[-1]\n \n if os.path.exists(self.outfile):\n output = h5py.File(self.outfile,'a')\n else:\n output = h5py.File(self.outfile,'w')\n\n # Set permissions and group\n if self.set_permissions:\n try:\n os.chmod(self.outfile,0o664)\n shutil.chown(self.outfile, group=self.permissions_group)\n except PermissionError:\n self.logger(f'{fname}:{self.name}: Warning, couldnt set the file permissions.')\n\n # Store datasets in root\n data_out = {'tod':self.all_tod,\n 'weights':self.all_weights,\n 'mask':self.all_mask,\n 'cal_factors':self.all_cal_factors,\n 'frequency':self.all_frequency,\n 'auto_rms':self.all_auto}\n\n for dname, dset in data_out.items():\n if dname in output:\n del output[dname]\n output.create_dataset(dname, data=dset)\n\n output.attrs['version'] = __level3_version__\n output['cal_factors'].attrs['source'] = self.cal_source\n output['cal_factors'].attrs['calibrator_obsid'] = self.nearest_calibrator\n\n output.close()\n \n if self.level3 in data.keys():\n del data[self.level3]\n data[self.level3] = h5py.ExternalLink(self.outfile,'/')","def __load_dir_structure_file__(self):\n # | - __load_dir_structure_file__\n try:\n try:\n fle_name = self.root_dir + \"/jobs_bin/dir_structure.json\"\n\n with open(fle_name, \"r\") as dir_struct_f:\n data = json.load(dir_struct_f)\n\n tree_level = data[\"tree_level_labels\"]\n level_entries = data[\"level_entries_dict\"]\n\n if \"skip_dirs\" in data.keys():\n skip_dirs_lst = data[\"skip_dirs\"]\n self.skip_dirs_lst = skip_dirs_lst\n\n self.tree_level_labels = tree_level\n self.level_entries = level_entries\n self.level_entries_list = level_entries\n\n except:\n print(\"Couldn't read /jobs_bin/dir_structure.json\")\n\n try:\n\n # | - __old__\n tmp = 42\n # print(\"old - Reading dir_structure.json file \\\n # from root_dir\")\n #\n # fle_name = self.root_dir + \"/dir_structure.json\"\n # with open(fle_name, \"r\") as dir_struct_f:\n # data = json.load(dir_struct_f)\n # tree_level = data[\"tree_level_labels\"]\n # level_entries = data[\"level_entries_dict\"]\n #\n # if \"skip_dirs\" in data.keys():\n # skip_dirs_lst = data[\"skip_dirs\"]\n # self.skip_dirs_lst = skip_dirs_lst\n #\n # self.tree_level_labels = tree_level\n # self.level_entries = level_entries\n # __|\n\n except:\n print(\"Couldn't read /dir_structure.json\")\n\n pass\n\n except:\n mess = \"Error opening 'dir_structure.json' file\"\n raise IOError(mess)\n\n # __|","def generate_tree(self, max_depth = None):\n\n if max_depth is None:\n max_depth = self.tree.max_depth\n else:\n max_depth -= 1\n if max_depth == 0:\n return\n self.generate_children()\n if self.tree.remove:\n os.unlink(self.source_filename)\n for child in self.children:\n if child.count > self.tree.max_count:\n child.generate_tree(max_depth)","def __init__(self, settings):\n\n #self.e_tree = settings.e_tree # Don't do this!!!! change all calls to e_tree to self.settings.e_tree!\n #self.k_tree = settings.k_tree\n self.settings = settings\n self.made_parents = {}\n self.added_files = {}\n self.edit_files = {}","def prettify(tree, indent=0):\n for key, value in six.iteritems(tree):\n if key == FILE_MARKER:\n if value:\n print((' ' * indent + str(value)))\n else:\n print((' ' * indent + str(key)))\n if isinstance(value, dict):\n prettify(value, indent+1)\n else:\n print((' ' * (indent+1) + str(value)))","def __manage_tree(self):\n for pre, fill, node in RenderTree(self.tree):\n if node.name is 'count':\n logger.info(\n \"Tree info %s%s: %s %s p/s attack: %s\",\n pre, node.name, node.value, node.pps, node.attack)\n else:\n logger.info(\"Pre - [%s], Fill - [%s], Node - [%s]\",\n pre, fill, node.name)","def optimized_work_tree(obj, **kwargs):\n exclusions = kwargs.get('exclusions', {\"groups\": [], \"classes\": [], \"params\": []})\n groups_done = {}\n classes = {\"depths\": {}, \"content\": {}}\n params = {\"depths\": {}, \"content\": {}}\n if hasattr(obj, 'hostname') and not hasattr(obj, 'name'):\n obj.name = obj.hostname\n to_index = [(obj, 1)]\n\n index_pop = to_index.pop\n index_extend = to_index.extend\n while to_index:\n (obj, depth) = index_pop()\n objname = obj.name\n if objname in groups_done and groups_done[objname] <= depth:\n continue\n\n objclasses = obj.classes.exclude(classname__in=exclusions['classes'])\n updated_classes = optimized_update_values(objclasses, \"classname\", \"classparams\", depth=depth, results=classes)\n\n objparams = obj.parameters.exclude(paramkey__in=exclusions['params'])\n updated_params = optimized_update_values(objparams, \"paramkey\", \"paramvalue\", depth=depth, results=params)\n\n if not updated_classes or not updated_params:\n return (\"Fail\", \"Fail\")\n\n groups_done[objname] = depth\n depth += 1\n children = ((group, depth) for group in obj.groups.exclude(name__in=exclusions['groups']))\n index_extend(children)\n\n params['content']['done_count'] = len(groups_done)\n return (classes[\"content\"], params[\"content\"])","def traverse_tree(file, tree):\n\n\tfor node in tree.get_children():\n\t\tpass","def _dfs_postorder(node, visited):\n\t# print(\"_dfs_postorder\")\n\tif node.lo is not None:\n\t\tyield from _dfs_postorder(node.lo, visited)\n\tif node.hi is not None:\n\t\tyield from _dfs_postorder(node.hi, visited)\n\tif node not in visited:\n\t\tvisited.add(node)\n\t\tyield node","def test_hierarchies(self):\n compare_file_hierarchy(self, file_hierarchy(self.file_hierarchy_dict))","def main():\n\n ''' Reading the training data file '''\n original_training_data = pd.read_csv(\"DT_Data_CakeVsMuffin_v012_TRAIN.csv\")\n\n ''' Storing the final decision tree '''\n final_tree = decision_tree(original_training_data,0)\n\n ''' Printing the final decision tree '''\n print(\"This is the resulting decision tree: \\n\")\n print(final_tree)\n\n ''' Iterating through the dictionary by using the key values '''\n for key in final_tree.keys():\n ''' Parent = Flour <= 5.1636'''\n parent = key\n ''' left_child = [{'Oils <= 3.1265': [{'Flour <= 2.7291': [{'Proteins <= 2.6527': ['Muffin', 'CupCake']}, 'Muffin']}, 'CupCake']}'''\n left_child = final_tree[parent][0]\n ''' right_child = {'Oils <= 7.7793': ['Muffin', {'Flour <= 8.2225': ['CupCake', 'Muffin']}]}]'''\n right_child = final_tree[parent][1]\n\n ''' Writing a file which generates code for classification '''\n file = open('HW06_Parchand_Nihal_Classifier.py','w+')\n file.write(\"'''Importing libraries''' \"\n \"\\n\\nimport pandas as pd \\n\\ndef main():\"\n \"\\n\\tdata_df = pd.read_csv('DT_Data_CakeVsMuffin_v012_TEST.csv')\"\n \"\\n\\tresult = []\"\n \"\\n\\tfor row in range(0,len(data_df)):\"\n \"\\n\\t\\tFlour = data_df.loc[row][0]\"\n \"\\n\\t\\tSugar = data_df.loc[row][1]\"\n \"\\n\\t\\tOils = data_df.loc[row][2]\"\n \"\\n\\t\\tProteins = data_df.loc[row][3]\"\n \"\\n\\t\\tif {}:\\n\".format(parent))\n\n ''' Iterating through the left_tree '''\n for key in left_child.keys():\n file.write(\"\\t\\t\\tif {}:\\n\".format(key))\n\n ''' Iterating through the inner left_tree '''\n for inner_key in left_child[key][0].keys():\n file.write(\"\\t\\t\\t\\tif {}:\\n\".format(inner_key))\n\n for inner_inner_key in ((left_child[key][0])[inner_key])[0]:\n file.write(\"\\t\\t\\t\\t\\tif {}:\\n\".format(inner_inner_key))\n file.write(\"\\t\\t\\t\\t\\t\\tresult.append(0)\\n\")\n file.write(\"\\t\\t\\t\\t\\telse:\\n\".format(inner_inner_key))\n file.write(\"\\t\\t\\t\\t\\t\\tresult.append(1)\\n\")\n\n file.write(\"\\t\\t\\t\\telse:\\n\")\n file.write(\"\\t\\t\\t\\t\\tresult.append(0)\\n\")\n file.write(\"\\t\\t\\telse:\\n\")\n file.write(\"\\t\\t\\t\\tresult.append(1)\\n\")\n file.write(\"\\t\\telse:\\n\")\n\n ''' Iterating through the right_tree '''\n for key in right_child.keys():\n file.write(\"\\t\\t\\tif {}:\\n\".format(key))\n file.write(\"\\t\\t\\t\\tresult.append(0)\\n\")\n for inner_key in right_child[key][1].keys():\n file.write(\"\\t\\t\\telif {}:\\n\".format(inner_key))\n file.write(\"\\t\\t\\t\\tresult.append(1)\\n\")\n file.write(\"\\t\\t\\telse:\\n\")\n file.write(\"\\t\\t\\t\\tresult.append(0)\\n\\n\")\n\n ''' Writing the results of classifier to a csv file '''\n file.write(\n \"\\twith open('HW06_Parchand_Nihal_MyClassifications.csv', 'w+') as file2:\\n\"\n \"\\t\\tfor value in result:\\n\"\n \"\\t\\t\\tfile2.write(str(value))\\n\"\n \"\\t\\t\\tfile2.write('\\\\n')\\n\\n\"\n \"main()\")","def _walk_dirs(self):\n for project_name in self.new_source_paths.keys():\n # print \"-------- Now mapping ---- \" + project_name\n search_path = self.root + project_name + '\\\\Data'\n for dirpath, subdirs, files in os.walk(search_path):\n for file in files:\n self.new_source_paths[project_name][file] = dirpath\n # print \"------------ Finished mapping ------- \" + project_name\n return self.new_source_paths","def _trickle_up(im, node, parents, merge, depth):\n\n n, x, y = node.n, node.x, node.y\n\n pth = os.path.join('%i' % n, '%i' % y, '%i_%i.png' % (y, x))\n\n nparent = sum(len(v) for v in parents.values())\n assert nparent <= 4 * max(depth, 1)\n\n if depth >= n: # handle special case of depth=0, n=1\n yield pth, im\n\n if n == 0:\n return\n\n # - If not merging and not at level 1, no need to accumulate\n if not merge and n > 1:\n return\n\n parent, xc, yc = _parent(node)\n corners = parents[parent]\n corners[(xc, yc)] = im\n\n if len(corners) < 4: # parent not yet ready\n return\n\n parents.pop(parent)\n ul = corners[(0, 0)]\n ur = corners[(1, 0)]\n bl = corners[(0, 1)]\n br = corners[(1, 1)]\n mosaic = np.vstack((np.hstack((ul, ur)), np.hstack((bl, br))))\n im = (merge or _default_merge)(mosaic)\n\n for item in _trickle_up(im, parent, parents, merge, depth):\n yield item","def do_all_the_things(data):\n \n os.mkdir('./temp-blocks')\n for block in data:\n if not os.path.exists('./pages/index.css'):\n write.imports_to_index(block)\n declarations = read.get_declaration_blocks(block)\n\n elems_and_mods = data[block]\n if elems_and_mods:\n for elem_or_mod in elems_and_mods:\n if elem_or_mod.startswith('__'):\n build_elem_file_structure(block, elem_or_mod, data, \n declarations)\n else:\n build_mod_file_structure(block, elem_or_mod, data, \n declarations, isBlock=True)\n\n rewrite_block_css_files(block, data, declarations) \n os.rmdir('./temp-blocks')","def update_level(self):\n level = 1\n assigned_levels = set([])\n just_assigned = set([])\n for root in self.roots:\n for child in root.children:\n if child in just_assigned:\n continue\n child.level = level\n if len(child.children) == 0:\n continue\n just_assigned.add(child)\n assigned_levels = assigned_levels.union(just_assigned)\n\n level += 1\n leaves = [c for c in self.collectors if len(c.children) == 0]\n len_non_leaves = len(self.collectors) - len(leaves)\n self.update_level_for_non_leaves(\n level, assigned_levels, just_assigned, len_non_leaves\n )","def reaching_definitions(self):\n dirty = True\n while dirty:\n dirty = False\n for block in self.blocks:\n i_input = 0\n for parent in block.parents:\n i_input |= parent.i_output\n i_output = (i_input & ~block.i_kill) | block.i_gen\n if i_output != block.i_output:\n dirty = True\n block.i_input = i_input\n block.i_output = i_output","def reaching_definitions(self):\n dirty = True\n while dirty:\n dirty = False\n for block in self.blocks:\n i_input = 0\n for parent in block.parents:\n i_input |= parent.i_output\n i_output = (i_input & ~block.i_kill) | block.i_gen\n if i_output != block.i_output:\n dirty = True\n block.i_input = i_input\n block.i_output = i_output","def post_ancestry(self, ancestry):\n raise NotImplementedError(\"Implement in sub classes\")","def traverseTree(mdsnode,dead_branches=False,depth=float('Nan'),current_depth=0,noisy=False,strict=False,tags=False):\n tagdict={}\n if isinstance(mdsnode,mds.tree.Tree): \n mdsnode=mdsnode.getNode(\"\\\\TOP\")\n \n name = get_mds_shortname(mdsnode) \n me = Branch(mdsnode)#put node information here if you like\n if noisy: print (\" \"*current_depth + name)\n\n #Members are data/signals, put them directly the current Node object\n #if they are arrays\n if mdsnode.getNumMembers()>0:\n leaves=mdsnode.getMembers()\n for leaf in leaves:\n leafname=get_mds_shortname(leaf)\n leafshape=get_mds_shape(leaf)\n if dead_branches or not len(leafshape) ==0:\n if noisy: print (\" \"*(current_depth+1) + leafname +\": array%s\"%str(leafshape))\n setattr(me,leafname,Leaf(leaf,strict))\n tagdict[leafname]=getattr(me,leafname)\n else:\n if noisy: print(\" \"*(current_depth+1) + leafname)\n #Children contain no immediate data, just links to more nodes. If depth is\n #not beyond limit, go down these 'branches' and add contents to the current\n #Node object\n if not depth <= current_depth and mdsnode.getNumChildren()>0:\n branches = mdsnode.getChildren()\n for b in branches:\n subname,subnode,subtags=traverseTree(b, dead_branches,depth,current_depth+1,noisy,strict)\n if len(subnode.__getDescendants__())>0:\n setattr(me,subname,subnode)\n tagdict[subname]=getattr(me,subname)\n for k,v in subtags.items(): #merge tags in\n tagdict[k]=v\n \n if current_depth==0:#we are done, returning to user\n if tags: \n for tag,obj in tagdict.items():\n setattr(me,tag,obj)\n else:\n tagbranch=Branch(mdsnode)\n for tag,obj in tagdict.items():\n setattr(tagbranch,tag,obj)\n setattr(me,'tags',tagbranch) \n return me\n return (name, me,tagdict) #else, we are still recursing back down the tree","def dfs_postorder(self):\n\t\t# print(\"Class BinaryDecisionDiagram _dfs_postorder\")\n\t\tyield from _dfs_postorder(self.node, set())","def set_depth(self):\n if self.depth != None:\n return\n if not self.parents:\n self.depth = 0\n return\n for parent in self.parents:\n parent.set_depth()\n \n depths = [parent.depth for parent in self.parents]\n self.depth = max(depths) + 1","def walk_files():\n\n # TODO: not check twice the same dir or file\n for path in config.targets:\n abs_path = os.path.join(cwd, path)\n\n if not os.path.islink(abs_path) and os.path.isfile(abs_path):\n walked.append(abs_path)\n yield abs_path\n #process_file(abs_path)\n\n if os.path.isdir(abs_path):\n walked.append(abs_path)\n for root, dirs, files in os.walk(abs_path):\n for fname in files:\n if isbackup(fname):\n continue\n abs_path = os.path.join(root, fname)\n walked.append(abs_path)\n if not os.path.islink(abs_path) and\\\n os.path.isfile(abs_path):\n base, name = os.path.split(abs_path)\n XXX, ext = os.path.splitext(name)\n\n ignored = False\n for pattern in IGNORE_FILES:\n if pattern.search(fname):\n ignored = True\n break\n\n # maybe should be merged with IGNORE_FILES?\n for regexp in config.exclude_list:\n if regexp.search(fname):\n ignored = True\n break\n\n if not ignored:\n for test_ext in config.disallow_exts:\n if test_ext == ext:\n ignored = True\n break\n\n if not ignored:\n if config.allow_exts:\n ignored = True\n for test_ext in config.allow_exts:\n if test_ext == ext:\n ignored = False\n break\n\n if not ignored:\n yield abs_path\n #process_file(abs_path)\n\n for dir in dirs[:]:\n if dir in IGNORE_DIRS:\n dirs.remove(dir)\n if dir in dirs:\n dirs.remove(dir)\n # mayb be should be merged with IGNORE_DIRS?\n else:\n for regexp in config.exclude_list:\n if regexp.search(dir):\n # This check is required\n # because several different patterns\n # could match one file name\n if dir in dirs:\n dirs.remove(dir)\n\n for dir in dirs:\n abs_path = os.path.join(root, dir)\n walked.append(abs_path)","def WriteVmInfo(vm, depth=1):\n #print('ModelSay.py - Writing VMs to Graph')\n maxdepth = 10\n global folder\n # if this is a group it will have children. if it does, recurse into them\n # and then return\n if hasattr(vm, 'childEntity'):\n if depth > maxdepth:\n return\n #print('VM Folder: %s' % vm.name)\n\n #global folder \n folder = vm.name\n vmList = vm.childEntity\n for c in vmList:\n WriteVmInfo(c, depth+1)\n return\n\n vm_node = BuildNode(vm)","def set_global_properties(self, validate=False):\n # Tree num array\n self.treenum_arr = np.zeros(self.totnhalos, dtype='int64')\n start = self.nhalos_before_tree\n stop = start + self.nhalos_per_tree\n for t in range(self.ntrees):\n self.treenum_arr[start[t]:stop[t]] = t\n # Memmap/file object\n self.fobj = np.memmap(self.filename, dtype=self.item_dtype, mode='c',\n offset=self.header_size)\n # Read all data\n data = self.read_all_trees(skip_add_fields=True, validate=validate)\n # File number\n self.filenum = data['FileNr'][0]\n if (data['SnapNum'][0] + 1) != len(self.scale_factors): # pragma: no cover\n ytreeLogger.warning(\n f\"First FoF central is in snapshot {data['SnapNum'][0] + 1}/{len(self.scale_factors)}.\")\n # Halo unique IDs\n self.all_uids = np.bitwise_or(\n np.int64(self.filenum) << 32, np.arange(self.totnhalos, dtype='int64'))\n # Get descendant unique IDs\n desc = data['Descendant']\n pos_flag = (desc >= 0)\n desc_uid = np.zeros(self.totnhalos, dtype='int64') - 1\n desc_abs = self.get_total_index(self.treenum_arr, desc)\n desc_uid[pos_flag] = self.all_uids[desc_abs[pos_flag]]\n self.all_desc_uids = desc_uid\n # Add fields and cache root fields\n data = self.add_computed_fields(-1, data, validate=validate)\n root_idx = self.nhalos_before_tree\n self._root_data = dict()\n for k in self.fields:\n self._root_data[k] = data[k][root_idx]","def generate_tree_postorder(node_lst, root_index):","def _WalkFolders(self, folder_dict, parent):\n entries = folder_dict.keys()\n entries.sort()\n for e in entries:\n if folder_dict[e]:\n # Folder\n n_subfolder = self.doc.createElement('Filter')\n n_subfolder.setAttribute('Name', e)\n parent.appendChild(n_subfolder)\n self._WalkFolders(folder_dict[e], n_subfolder)\n else:\n # File\n n_file = self.doc.createElement('File')\n n_file.setAttribute('RelativePath', e)\n parent.appendChild(n_file)","def save_to_temp(obj, file_name, xml_file, node, hash_id, routine=\"temp_file\"):\n root = xml_file.getroot()\n try:\n output = root.find(\"saved_files\").attrib[\"path\"]\n except KeyError:\n output = None\n if output is not None:\n dir_name = output\n else:\n dir_name = os.path.dirname(file_name)\n parent_name = os.path.basename(dir_name)\n print(\"Saving \" + routine + \" to file\")\n print(\"Output folder: \" + dir_name)\n model_name = root.attrib['name']\n save_folder = \"/saved_files/\" + routine +\"-\"+model_name+ \"_\" +str(hash_id)+ \".bp\"\n\n filename = dir_name+save_folder\n\n relative_path=dir_name+save_folder\n if not os.path.isdir(dir_name+\"/saved_images\"):\n os.mkdir(dir_name+\"/saved_images\")\n for i in plt.get_fignums():\n if i not in saved_already:\n saved_already.append(i)\n Plotting.figure(i)\n save_image_folder = '/saved_images/'+routine+\"-\"+model_name+'-figure%d.png' % i\n Plotting.savefig(dir_name+save_image_folder)\n try:\n Utility.save(obj, filename)\n except IOError:\n os.mkdir(dir_name+\"/saved_files/\")\n Utility.save(obj, filename)\n node.set('path', relative_path)\n root = xml_file.getroot()\n indent(root)\n xml_file.write(file_name)","def set_depth(self, d):\r\n self.depth = d","def _fixupChildren(self, ph, alogger):\n name = alogger.name\n namelen = len(name)\n for c in ph.loggerMap.keys():\n #The if means ... if not c.parent.name.startswith(nm)\n if c.parent.name[:namelen] != name:\n alogger.parent = c.parent\n c.parent = alogger","def create_recursive(replace_dict, step_index, directories, dependency_level, keys=[]):\n\n # check if we are at the lowest level\n if step_index == len(steps):\n # create a call and execute it\n if check_requirements(replace_dict):\n execute_dependent_task(create_command_line(replace_dict), directories, dependency_level)\n else:\n if steps[step_index] not in directories:\n directories[steps[step_index]] = []\n\n # we are at another level\n if steps[step_index] not in configuration.replace.keys():\n # nothing to be replaced here, so just go to the next level\n create_recursive(replace_dict, step_index+1, directories, dependency_level)\n else:\n # iterate through the keys\n if keys == []:\n # call this function recursively by defining the set of keys that we need\n create_recursive(replace_dict, step_index, directories, dependency_level, keys = sorted(configuration.replace[steps[step_index]].keys()))\n else:\n # create a deep copy of the replacement dict to be able to modify it\n replace_dict_copy = copy.deepcopy(replace_dict)\n directories_copy = copy.deepcopy(directories)\n # iterate over all replacements for the first of the keys\n key = keys[0]\n replacement_directories = sorted(configuration.replace[steps[step_index]][key])\n directories_copy[steps[step_index]].append(\"\")\n new_dependency_level = dependency_level\n for replacement_index in range(len(replacement_directories)):\n # increase the counter of the current replacement\n replace_dict_copy[key] = replacement_index\n directories_copy[steps[step_index]][-1] = replacement_directories[replacement_index]\n # call the function recursively\n if len(keys) == 1:\n # we have to go to the next level\n create_recursive(replace_dict_copy, step_index+1, directories_copy, new_dependency_level)\n else:\n # we have to subtract the keys\n create_recursive(replace_dict_copy, step_index, directories_copy, new_dependency_level, keys = keys[1:])\n new_dependency_level = step_index","def reconstruct_ancestry(self, parent_ancestry):\n self._construct_ancestry(parent_ancestry)\n for flag in self.flags:\n flag.reconstruct_ancestry(self.ancestry)","def _initialize_trees(self):","def preRead(force,cat,path,depth = 0,retries = 0):\n limit = 6 # Lower limit for printing debug messages in this function\n root = None\n if cat == 'p':\n global people\n root = people\n elif cat == 'l':\n global places\n root = places\n elif cat == 'c':\n global cities\n root = cities\n elif cat == 's':\n global states\n root = states\n elif cat == 'o':\n global orgs\n root = orgs\n elif cat == 'i':\n global items\n root = items\n else:\n print \"ERR: Invalid category %s passed to markChanged.\" % cat\n if not root:\n print \"preRead: Invalid category %s?\" % cat\n return False\n if depth > len(path): depth = len(path)\n if depth > 7: depth = 7\n if path[0] in root.keys():\n if depth <= 1:\n return True\n if path[1] in root[path[0]].keys():\n if depth <= 2:\n return True\n if path[2] in root[path[0]][path[1]].keys():\n if depth <= 3:\n return True\n if path[3] in root[path[0]][path[1]][path[2]].keys():\n if depth <= 4:\n return True\n if path[4] in root[path[0]][path[1]][path[2]][path[3]].keys():\n if depth <= 5:\n return True\n if path[5] in root[path[0]][path[1]][path[2]][path[3]][path[4]].keys():\n if depth <= 6:\n return True\n if path[6] in root[path[0]][path[1]][path[2]][path[3]][path[4]][path[5]].keys():\n return True # Maximum depth reached\n elif force:\n root[path[0]][path[1]][path[2]][path[3]][path[4]][path[5]][path[6]] = {}\n if retries >= depth: force = False\n return preRead(force,cat,path,depth,retries + 1)\n else: # Not found, and not forcing it to be found\n if config['debug'] > limit: debugPath(root,path)\n return False\n elif force:\n root[path[0]][path[1]][path[2]][path[3]][path[4]][path[5]] = {}\n if retries >= depth: force = False\n return preRead(force,cat,path,depth,retries + 1)\n else: # Not found, and not forcing it to be found\n if config['debug'] > limit: debugPath(root,path)\n return False\n elif force:\n root[path[0]][path[1]][path[2]][path[3]][path[4]] = {}\n if retries >= depth: force = False\n return preRead(force,cat,path,depth,retries + 1)\n else: # Not found, and not forcing it to be found\n if config['debug'] > limit: debugPath(root,path)\n return False\n elif force:\n root[path[0]][path[1]][path[2]][path[3]] = {}\n if retries >= depth: force = False\n return preRead(force,cat,path,depth,retries + 1)\n else: # Not found, and not forcing it to be found\n if config['debug'] > limit: debugPath(root,path)\n return False\n elif force:\n root[path[0]][path[1]][path[2]] = {}\n if retries >= depth: force = False\n return preRead(force,cat,path,depth,retries + 1)\n else: # Not found, and not forcing it to be found\n if config['debug'] > limit: debugPath(root,path)\n return False\n elif force:\n root[path[0]][path[1]] = {}\n if retries >= depth: force = False\n return preRead(force,cat,path,depth,retries + 1)\n else: # Not found, and not forcing it to be found\n if config['debug'] > limit: debugPath(root,path)\n return False\n else: # First level (fileid) can't be generated.\n if config['debug'] > limit: debugPath(root,path)\n return False","def dfsHelper(self, root, nodes):\n if root.id > 0:\n nodes[root.id] = root\n\n for neighbor in root.neighbors:\n self.dfsHelper(neighbor, nodes)","def test_nested_settings_files(tmpdir):\n subfolder = tmpdir.mkdir(\"sub\")\n p = subfolder.join(\"settings.json\")\n nested_1_p = subfolder.join(\"nested_1.json\")\n nested_2_p = subfolder.join(\"nested_2.json\")\n\n nested_2_p.write(json.dumps({\"foo\": 1, \"bar\": 2}))\n nested_1_p.write(json.dumps({\"level_2_from_file\": str(nested_2_p)}))\n p.write(\n json.dumps(\n {\n \"level_1_from_file\": str(\n nested_1_p\n ), # nested_1_p references nested_2_p internally.\n \"spam\": \"parrot\",\n \"list\": [\n \"random\",\n {\n \"this_from_file\": str(\n nested_2_p\n ) # dictionaries in lists should be expanded as well.\n },\n ],\n }\n )\n )\n\n climate = core.Climate(prefix=\"TEST_STUFF\", settings_files=[str(p)])\n assert dict(climate.settings) == {\n \"spam\": \"parrot\",\n \"level_1\": {\"level_2\": {\"foo\": 1, \"bar\": 2}},\n \"list\": [\"random\", {\"this\": {\"foo\": 1, \"bar\": 2}}],\n }","def iter_dir(tree, path):\n for f in os.listdir(path):\n if os.path.isfile(path + '/' + f + '/__init__.py'):\n tree[f] = None\n elif os.path.isdir(path + '/' + f):\n tree[f] = {}\n SnakeWM.iter_dir(tree[f], path + '/' + f)","def write_map( file_lists, target_dir, output_dir ):\n tld_to_volumes = {}\n for i, group in enumerate( file_lists ):\n for node in group:\n tld = toplevel_subdir( node, target_dir )\n tld_to_volumes.setdefault( tld, set() ).add( i )\n with open( os.path.join( output_dir, \"map.txt\" ), \"w\" ) as fout:\n for tld, volumes in tld_to_volumes.items():\n fout.write( \"{:24s}: {}\\n\".format( tld, \" \".join( [ str( x ) for x in volumes ] ) ) )","def test_level2_recursion(self):\n recursed = recurse_files('filename2', self.files['filename2'], self.files)\n self.assertEqual(recursed, [\"file7\", \"file2\", \"file3\", \"file6\"])","def _set_path(self):\n self.path = self._get_path()\n self.depth = self.get_depth()\n\n self.save()","def atree(dir,\n print_files=True,\n outfile=None):\n\n nodes = dict()\n nodes[dir] = Node(dir)\n root_node = nodes[dir]\n for root, dirs, files in os.walk(dir, topdown=True):\n if root not in nodes:\n nodes[root] = Node(root)\n for name in files:\n if print_files:\n nodes[os.path.join(root, name)] = \\\n Node(name, parent=nodes[root])\n for name in dirs:\n nodes[os.path.join(root, name)] = Node(name, parent=nodes[root])\n\n output = []\n for pre, fill, node in RenderTree(root_node):\n output.append((f'{ pre }{ node.name }'))\n if outfile is not None:\n for line in output:\n print(line, file=outfile)\n else:\n return output","def Init(self):\n # First iteration over all the files in root searching for symlinks and\n # non-regular files.\n seen_inodes = {}\n for basepath, _, filenames in sorted(os.walk(self._root)):\n for filename in sorted(filenames):\n full_path = os.path.join(basepath, filename)\n rel_path = full_path[len(self._root):]\n st = os.lstat(full_path)\n\n file_data = {\n 'size': st.st_size,\n }\n self._files[rel_path] = file_data\n\n # Track symlinks.\n if stat.S_ISLNK(st.st_mode):\n link_path = os.readlink(full_path)\n # lddtree's normpath handles a little more cases than the os.path\n # version. In particular, it handles the '//' case.\n self._symlinks[rel_path] = (\n link_path.lstrip('/') if link_path and link_path[0] == '/' else\n lddtree.normpath(os.path.join(os.path.dirname(rel_path),\n link_path)))\n file_data['deps'] = {\n 'symlink': [self._symlinks[rel_path]]\n }\n\n # Track hardlinks.\n if st.st_ino in seen_inodes:\n self._hardlinks[rel_path] = seen_inodes[st.st_ino]\n continue\n seen_inodes[st.st_ino] = rel_path","def get_tree_size(thread, root, top, path, docs, sizes, inodes, depth=0, maxdepth=999):\n global filecount\n global skipfilecount\n global inodecount\n global dircount\n global skipdircount\n global total_doc_count\n global warnings\n\n size = 0\n size_du = 0\n dirs = 0\n files = 0\n f_count = 0\n d_count = 0\n f_skip_count = 0\n d_skip_count = 0\n tot_doc_count = 0\n parent_path = None\n size_norecurs = 0\n size_du_norecurs = 0\n files_norecurs = 0\n dirs_norecurs = 0\n \n # use alt scanner\n # try to get stat info for dir path\n if options.altscanner:\n try:\n d_stat = alt_scanner.stat(path)\n except RuntimeError as e:\n logmsg = '[{0}] ALT SCANNER ERROR: {1}'.format(thread, e)\n logger.error(logmsg)\n if logtofile: logger_warn.error(logmsg)\n with crawl_thread_lock:\n warnings += 1\n return 0, 0, 0, 0\n except Exception as e:\n logmsg = '[{0}] ALT SCANNER EXCEPTION: {1}'.format(thread, e)\n logger.exception(logmsg)\n if logtofile: logger_warn.exception(logmsg)\n with crawl_thread_lock:\n warnings += 1\n return 0, 0, 0, 0\n else:\n # try to get os stat info for dir path\n try:\n d_stat = os.stat(path)\n except OSError as e:\n logmsg = '[{0}] OS ERROR: {1}'.format(thread, e)\n logger.warning(logmsg)\n if logtofile: logger_warn.warning(logmsg)\n with crawl_thread_lock:\n warnings += 1\n return 0, 0, 0, 0\n \n # restore times (atime/mtime)\n if restore_times:\n res, err = set_times(path, d_stat.st_atime, d_stat.st_mtime)\n if not res:\n logmsg = 'OS ERROR setting file times for {0} (error {1})'.format(path, err)\n logger.warning(logmsg)\n if logtofile: logger_warn.warning(logmsg)\n with crawl_thread_lock:\n warnings += 1\n\n # scan directory\n try:\n logger.debug('[{0}] Scanning path {1}...'.format(thread, path))\n if options.verbose or options.vverbose:\n logger.info('[{0}] Scanning path {1}...'.format(thread, path))\n for entry in os.scandir(path):\n logger.debug('[{0}] Scanning dir entry {1}...'.format(thread, entry.path))\n if options.vverbose:\n logger.info('[{0}] Scanning dir entry {1}...'.format(thread, entry.path)) \n \n if entry.is_symlink():\n logger.debug('[{0}] skipping symlink {1}'.format(thread, entry.path))\n if options.verbose or options.vverbose:\n logger.info('[{0}] skipping symlink {1}'.format(thread, entry.path))\n pass\n elif entry.is_dir():\n d_count += 1\n if not dir_excluded(entry.path):\n dirs += 1\n dirs_norecurs += 1\n if maxdepth > 0:\n if depth < maxdepth:\n # recurse into subdir\n if not quit:\n s, sdu, fc, dc = get_tree_size(thread, root, top, entry.path, docs, sizes, inodes, depth+1, maxdepth)\n size += s\n size_du += sdu\n files += fc\n dirs += dc\n else:\n logger.debug('[{0}] not descending {1}, maxdepth {2} reached'.format(\n thread, entry.path, maxdepth))\n if options.verbose or options.vverbose:\n logger.info('[{0}] not descending {1}, maxdepth {2} reached'.format(\n thread, entry.path, maxdepth))\n else:\n logger.debug('[{0}] skipping dir {1}'.format(thread, entry.path))\n if options.verbose or options.vverbose:\n logger.info('[{0}] skipping dir {1}'.format(thread, entry.path))\n d_skip_count += 1\n else:\n f_count += 1\n if not file_excluded(entry.name):\n f_stat = entry.stat()\n # restore times (atime/mtime)\n if restore_times and not options.altscanner:\n ret = set_times(entry.path, f_stat.st_atime, f_stat.st_mtime)\n if not ret:\n with crawl_thread_lock:\n warnings += 1\n\n fsize = f_stat.st_size\n # calculate allocated file size (du size)\n if IS_WIN:\n fsize_du = fsize\n elif options.altscanner:\n fsize_du = f_stat.st_sizedu\n else:\n fsize_du = f_stat.st_blocks * blocksize\n # set fsize_du to 0 if inode in inodes list (hardlink)\n if f_stat.st_ino in inodes:\n fsize_du = 0\n # add inode to inodes list if hardlink count > 1\n elif f_stat.st_nlink > 1:\n with crawl_thread_lock:\n inodes.append(f_stat.st_ino)\n fmtime_sec = time.time() - f_stat.st_mtime\n fctime_sec = time.time() - f_stat.st_ctime\n fatime_sec = time.time() - f_stat.st_atime\n\n if not exc_empty_files or (exc_empty_files and fsize > 0):\n if fsize >= minfilesize and \\\n fmtime_sec > minmtime and \\\n fmtime_sec < maxmtime and \\\n fctime_sec > minctime and \\\n fctime_sec < maxctime and \\\n fatime_sec > minatime and \\\n fatime_sec < maxatime:\n size += fsize\n size_norecurs += fsize\n size_du += fsize_du\n size_du_norecurs += fsize_du\n files += 1\n files_norecurs += 1\n # get owner and group names\n if IS_WIN:\n # for windows just set both owner and group to 0, this is what scandir returns for Windows\n # and there is no known fast way to get Windows file owner (pywin32 is slow)\n owner = f_stat.st_uid\n group = f_stat.st_gid\n else:\n owner, group = get_owner_group_names(f_stat.st_uid, f_stat.st_gid)\n \n # check for bad Unicode utf-8 characters\n try:\n if parent_path is None:\n parent_path = get_parent_path(entry.path)\n file_name = get_file_name(entry.name)\n except UnicodeError:\n if parent_path is None:\n parent_path = get_parent_path(entry.path, ignore_errors=True)\n file_name = get_file_name(entry.name, ignore_errors=True)\n logmsg = '[{0}] UNICODE WARNING {1}'.format(thread, os.path.join(parent_path, file_name))\n logger.warning(logmsg)\n if logtofile: logger_warn.warning(logmsg)\n with crawl_thread_lock:\n warnings += 1\n pass\n \n # index doc dict\n data = {\n 'name': file_name,\n 'extension': os.path.splitext(entry.name)[1][1:].lower(),\n 'parent_path': parent_path,\n 'size': fsize,\n 'size_du': fsize_du,\n 'owner': owner,\n 'group': group,\n 'mtime': datetime.utcfromtimestamp(int(f_stat.st_mtime)).isoformat(),\n 'atime': datetime.utcfromtimestamp(int(f_stat.st_atime)).isoformat(),\n 'ctime': datetime.utcfromtimestamp(int(f_stat.st_ctime)).isoformat(),\n 'nlink': f_stat.st_nlink,\n 'ino': str(f_stat.st_ino),\n 'type': 'file'\n }\n\n # check if using altscanner and if any additional meta data to add to data dict\n if options.altscanner:\n try:\n extrameta_dict = alt_scanner.add_meta(entry.path, f_stat)\n if extrameta_dict is not None:\n data.update(extrameta_dict)\n except Exception as e:\n logmsg = '[{0}] ALT SCANNER EXCEPTION {1}'.format(thread, e)\n logger.exception(logmsg)\n if logtofile: logger_warn.exception(logmsg)\n with crawl_thread_lock:\n warnings += 1\n pass\n # check plugins for adding extra meta data to data dict\n if plugins_enabled and plugins_files:\n for plugin in plugins:\n try:\n # check if plugin is for file doc\n if plugin.for_type('file'):\n extrameta_dict = plugin.add_meta(entry.path, f_stat)\n if extrameta_dict is not None:\n data.update(extrameta_dict)\n except (RuntimeWarning, RuntimeError) as e:\n err_message = e.args[0]\n if e.__class__ == RuntimeWarning:\n logmsg = '[{0}] PLUGIN WARNING: {1}'.format(thread, err_message)\n logger.warning(logmsg)\n if logtofile: logger_warn.warning(logmsg)\n else:\n logmsg = '[{0}] PLUGIN ERROR: {1}'.format(thread, err_message)\n logger.error(logmsg)\n if logtofile: logger_warn.error(logmsg)\n with crawl_thread_lock:\n warnings += 1\n extrameta_dict = e.args[1]\n if extrameta_dict is not None:\n data.update(extrameta_dict)\n except Exception as e:\n logmsg = '[{0}] PLUGIN EXCEPTION {1}'.format(thread, e)\n logger.exception(logmsg)\n if logtofile: logger_warn.exception(logmsg)\n with crawl_thread_lock:\n warnings += 1\n pass\n # add file doc to docs list and upload to ES once it reaches certain size\n docs.append(data.copy())\n doc_count = len(docs)\n if doc_count >= es_chunksize:\n start_bulk_upload(thread, root, docs)\n tot_doc_count += doc_count\n docs.clear()\n\n else:\n f_skip_count += 1\n logger.debug('[{0}] skipping file {1}'.format(thread, entry.path))\n if options.verbose or options.vverbose:\n logger.info('[{0}] skipping file {1}'.format(thread, entry.path))\n else:\n f_skip_count += 1\n logger.debug('[{0}] skipping file {1}'.format(thread, entry.path))\n if options.verbose or options.vverbose:\n logger.info('[{0}] skipping file {1}'.format(thread, entry.path))\n else:\n f_skip_count += 1\n logger.debug('[{0}] skipping file {1}'.format(thread, entry.path))\n if options.verbose or options.vverbose:\n logger.info('[{0}] skipping file {1}'.format(thread, entry.path))\n \n # if not excluding empty dirs is set or exclude empty dirs is set but there are files or \n # dirs in the current directory, index the dir\n if not exc_empty_dirs or (exc_empty_dirs and (files > 0 or dirs > 0)):\n # get owner and group names\n if IS_WIN:\n # for windows just set both owner and group to 0, this is what scandir returns for Windows\n # and there is no known fast way to get Windows file owner (pywin32 is slow)\n owner = d_stat.st_uid\n group = d_stat.st_gid\n else:\n owner, group = get_owner_group_names(d_stat.st_uid, d_stat.st_gid)\n \n # check for bad Unicode utf-8 characters\n try:\n file_name = get_dir_name(path)\n parent_path = get_parent_path(path)\n except UnicodeError:\n file_name = get_dir_name(path, ignore_errors=True)\n parent_path = get_parent_path(path, ignore_errors=True)\n logmsg = '[{0}] UNICODE WARNING {1}'.format(thread, os.path.join(parent_path, file_name))\n logger.warning(logmsg)\n if logtofile: logger_warn.warning(logmsg)\n with crawl_thread_lock:\n warnings += 1\n pass\n \n # index doc dict\n data = {\n 'name': file_name,\n 'parent_path': parent_path,\n 'size': size,\n 'size_norecurs': size_norecurs,\n 'size_du': size_du,\n 'size_du_norecurs': size_du_norecurs,\n 'file_count': files,\n 'file_count_norecurs': files_norecurs, \n 'dir_count': dirs + 1,\n 'dir_count_norecurs': dirs_norecurs + 1,\n 'dir_depth': depth,\n 'mtime': datetime.utcfromtimestamp(int(d_stat.st_mtime)).isoformat(),\n 'atime': datetime.utcfromtimestamp(int(d_stat.st_atime)).isoformat(),\n 'ctime': datetime.utcfromtimestamp(int(d_stat.st_ctime)).isoformat(),\n 'nlink': d_stat.st_nlink,\n 'ino': str(d_stat.st_ino),\n 'owner': owner,\n 'group': group,\n 'type': 'directory'\n }\n\n # check if using altscanner and if any additional meta data to add to data dict\n if options.altscanner:\n try:\n extrameta_dict = alt_scanner.add_meta(path, d_stat)\n if extrameta_dict is not None:\n data.update(extrameta_dict)\n except Exception as e:\n logmsg = '[{0}] ALT SCANNER EXCEPTION {1}'.format(thread, e)\n logger.exception(logmsg)\n if logtofile: logger_warn.exception(logmsg)\n with crawl_thread_lock:\n warnings += 1\n pass\n # check plugins for adding extra meta data to data dict\n if plugins_enabled and plugins_dirs:\n for plugin in plugins:\n # check if plugin is for directory doc\n try:\n if plugin.for_type('directory'):\n extrameta_dict = plugin.add_meta(path, d_stat)\n if extrameta_dict is not None:\n data.update(extrameta_dict)\n except (RuntimeWarning, RuntimeError) as e:\n err_message = e.args[0]\n if e.__class__ == RuntimeWarning:\n logmsg = '[{0}] PLUGIN WARNING: {1}'.format(thread, err_message)\n logger.warning(logmsg)\n if logtofile: logger_warn.warning(logmsg)\n else:\n logmsg = '[{0}] PLUGIN ERROR: {1}'.format(thread, err_message)\n logger.error(logmsg)\n if logtofile: logger_warn.error(logmsg)\n with crawl_thread_lock:\n warnings += 1\n extrameta_dict = e.args[1]\n if extrameta_dict is not None:\n data.update(extrameta_dict)\n except Exception as e:\n logmsg = '[{0}] PLUGIN EXCEPTION: {1}'.format(thread, e)\n logger.exception(logmsg)\n if logtofile: logger_warn.exception(logmsg)\n with crawl_thread_lock:\n warnings += 1\n pass\n \n if depth > 0:\n # add file doc to docs list and upload to ES once it reaches certain size\n docs.append(data.copy())\n doc_count = len(docs)\n if doc_count >= es_chunksize:\n start_bulk_upload(thread, root, docs)\n tot_doc_count += doc_count\n docs.clear()\n \n else:\n with crawl_thread_lock:\n sizes[root] = data.copy()\n else:\n d_skip_count += 1\n logger.debug('[{0}] skipping empty dir {1}'.format(thread, path))\n if options.verbose or options.vverbose:\n logger.info('[{0}] skipping empty dir {1}'.format(thread, path))\n if dirs > 0: dirs -= 1\n\n with crawl_thread_lock:\n dircount[root] += d_count - d_skip_count\n filecount[root] += f_count - f_skip_count\n skipfilecount[root] += f_skip_count\n skipdircount[root] += d_skip_count\n total_doc_count[root] += tot_doc_count\n inodecount[root] += d_count + f_count \n\n except OSError as e:\n logmsg = '[{0}] OS ERROR: {1}'.format(thread, e)\n logger.warning(logmsg)\n if logtofile: logger_warn.warning(logmsg)\n with crawl_thread_lock:\n warnings += 1\n pass\n except RuntimeError as e:\n logmsg = '[{0}] ALT SCANNER ERROR: {1}'.format(thread, e)\n logger.error(logmsg)\n if logtofile: logger_warn.error(logmsg)\n with crawl_thread_lock:\n warnings += 1\n pass\n \n return size, size_du, files, dirs","def _walk_dir(self, rootpath):\n assert os.path.isabs(rootpath)\n assert rootpath not in self._dirs\n relpath = self._get_rel_path(rootpath)\n self._dirs[relpath] = Directory(rootpath, relpath, None)\n for dirpath, dirnames, filenames in os.walk(rootpath):\n if 'refdata' in dirnames:\n dirnames.remove('refdata')\n currentdir = self._dirs[self._get_rel_path(dirpath)]\n # Loop through a copy so that we can modify dirnames.\n for dirname in list(dirnames):\n fullpath = os.path.join(dirpath, dirname)\n if fullpath == self._build_root:\n dirnames.remove(dirname)\n continue\n relpath = self._get_rel_path(fullpath)\n self._dirs[relpath] = Directory(fullpath, relpath, currentdir)\n extensions = ('.h', '.cuh', '.hpp', '.c', '.cc', '.cpp', '.cu', '.bm')\n for filename in filenames:\n basename, extension = os.path.splitext(filename)\n if extension in extensions:\n fullpath = os.path.join(dirpath, filename)\n relpath = self._get_rel_path(fullpath)\n self._files[relpath] = File(fullpath, relpath, currentdir)\n elif extension == '.cmakein':\n extension = os.path.splitext(basename)[1]\n if extension in extensions:\n fullpath = os.path.join(dirpath, filename)\n relpath = self._get_rel_path(fullpath)\n sourcefile = GeneratorSourceFile(fullpath, relpath, currentdir)\n self._files[relpath] = sourcefile\n fullpath = os.path.join(dirpath, basename)\n relpath = self._get_rel_path(fullpath)\n fullpath = os.path.join(self._build_root, relpath)\n generatedfile = GeneratedFile(fullpath, relpath, currentdir)\n self._files[relpath] = generatedfile\n generatedfile.set_generator_source(sourcefile)\n elif extension in ('.l', '.y', '.pre'):\n fullpath = os.path.join(dirpath, filename)\n relpath = self._get_rel_path(fullpath)\n self._files[relpath] = GeneratorSourceFile(fullpath, relpath, currentdir)","def GenerateHierarchies(self,id_range):\n classed = []\n file_list = self.GetFileList(id_range)\n if file_list:\n for fl in file_list:\n cls = self.GetClassesFromFile(fl)\n if cls:\n for c in cls:\n self.classes.append(c)\n\n for c in self.classes:\n if not self.Inherits(c):\n self.base_cls.append(c)\n self.classes.remove(c)\n\n for c in self.base_cls:\n kids = self.FindChilds(c)\n if c not in classed:\n root = self.AppendItem(self.root,self.CleanName(c))\n classed.append(c)\n if kids:\n for n in kids:\n root2 = self.AppendItem(root,self.CleanName(n))\n kids_kids = self.FindChilds(n)\n i = 0\n if kids_kids:\n kids_len = len(kids_kids)\n while kids_kids:\n try:\n kid = kids_kids[i]\n except: pass\n has_kid = self.FindChilds(kid)\n if not has_kid and i == kids_len: break\n i+=1\n root3 = self.AppendItem(root2,self.CleanName(kid))\n\n\n self.classes = []","def ND_params_tree(args):\n start = time.time()\n # We have some files recorded before there were flats, so get ready to\n # loop back for them\n skipped_dirs = []\n \n # list date directory one level deep\n totalcount = 0\n totaltorus = 0\n totalNa = 0\n totaltime = 0\n dirs = [os.path.join(args.directory, d)\n for d in os.listdir(args.directory) if os.path.isdir(os.path.join(args.directory, d))]\n persistent_default_ND_params = None\n for d in sorted(dirs):\n D.say(d)\n try:\n default_ND_params = get_default_ND_params(d)\n persistent_default_ND_params = default_ND_params\n except KeyboardInterrupt:\n # Allow C-C to interrupt\n raise\n except Exception as e:\n log.warning('Problem with flats: ' + str(e))\n if persistent_default_ND_params is None:\n log.error('No flats have been processed yet! Skipping directory')\n continue\n log.warning('Using previous value for default_ND_params')\n default_ND_params = persistent_default_ND_params\n \n (count, torus_count, Na_count, elapsed, T_per_file) \\\n = ND_params_dir(d, default_ND_params=default_ND_params)\n print(count, torus_count, Na_count, elapsed)\n totalcount += count\n totaltorus += torus_count\n totalNa += Na_count\n totaltime += elapsed\n end = time.time()\n D.say('Total elapsed time: ' + str(end - start) + 's')\n D.say(str(totalcount) + ' obj files took ' + str(totaltime) + 's')\n D.say('Average time per file: ' + str(totalcount / totaltime) + 's')\n D.say('Total torus: ' + str(totaltorus))\n D.say('Total Na: ' + str(totalNa))","def generate_output(input_filename: str, output_filename: str, goal_node: Node,\n generated: set) -> None:\n\n input_stream = io.open(input_filename, 'r', encoding='utf-8', errors='ignore',\n newline='\\n')\n with open(output_filename, 'w') as out_file:\n for i in range(0, 10):\n out_file.write(input_stream.readline().rstrip())\n out_file.write('\\n')\n \"\"\" The first ten lines of the output file are identical to those in the \n input file. The tenth line should be skipped because it's blank.\"\"\"\n out_file.write(str(goal_node.path_cost) + '\\n')\n # Line 11 of the output, the depth level d\n out_file.write(str(len(generated)) + '\\n')\n # Line 12 of the output, the total number of nodes generated\n\n # Writing Line 13 of the output, the sequence of moves\n length = len(goal_node.path_history)\n for i in range(length - 1):\n out_file.write(goal_node.path_history[i] + ' ')\n out_file.write(goal_node.path_history[length - 1] + '\\n')\n\n # Writing Line 14 of the output, the f(n) values\n f_line = str(goal_node.f) + ' '\n parent = goal_node.parent\n while parent: # Loop stops when parent == None\n f_line += (str(parent.f) + ' ')\n parent = parent.parent\n f_list = f_line.split(' ')\n # Breaks down the string to the integers it contains\n reverse = ''\n for i in range(len(f_list) - 2, -1, -1):\n # f_line[len(f_line)-1] is an extra whitespace character and\n # thus shouldn't be copied\n reverse += str(f_list[i])\n if i != 0:\n reverse += ' '\n \"\"\" The order of the f(n) values in f_line is from goal node \n to root node. The four lines above reverse the order, which \n is what the output format expects.\"\"\"\n out_file.write(reverse)\n\n out_file.close()","def recursive():\n with Local() as tun:\n tun.call(recursive)","def get(self):\n for path, dirs, files in os.walk(self.directory):\n folders = path[self.start:].split(os.sep)\n if self.branches:\n if self._filter(folders, 'folders'):\n files = dict.fromkeys(files)\n parent = reduce(dict.get, folders[:-1], self.tree_dict)\n parent[folders[-1]] = files\n else:\n files = dict.fromkeys(files)\n parent = reduce(dict.get, folders[:-1], self.tree_dict)\n parent[folders[-1]] = files\n return self.tree_dict","def build_auxiliary_structures(nodes_filename, ways_filename):\n nodes = {}\n for way in read_osm_data(ways_filename):\n highway_type = way['tags'].get('highway', '( ͡° ͜ʖ ͡°)')\n if highway_type in ALLOWED_HIGHWAY_TYPES:\n nodes_along_way = way['nodes'] # List of nodes along this way\n for i in range(len(nodes_along_way) - 1):\n # A pair of adjacent nodes along this way\n left = nodes_along_way[i]\n right = nodes_along_way[i + 1]\n default_speed_limit = DEFAULT_SPEED_LIMIT_MPH[highway_type]\n # If this way doesn't have a speed limit tag, we use the default value based on highway type\n speed_limit = way['tags'].get('maxspeed_mph', default_speed_limit)\n\n def build_data(root, adjacent):\n \"\"\"\n root: ID of some node along way\n adjacent: ID of some node adjacent to root node along way\n \"\"\"\n new_node_data_struct = {'adjacent': {adjacent: speed_limit}} # Init dict for node data structure\n root_data = nodes.get(root, new_node_data_struct)\n # There might be another way where root and adjacent are directly adjacent, so our\n # speed limit is the max of the speed limits of those two ways:\n root_data['adjacent'][adjacent] = max(root_data['adjacent'].get(adjacent, 0), speed_limit)\n nodes[root] = root_data # Add the data on root to our dictionary of node data\n\n build_data(left, right)\n if not way['tags'].get('oneway', '( ͡° ͜ʖ ͡°)') == 'yes':\n # If this isn't a oneway way, we can build the data structure for the next node as well\n build_data(right, left)\n elif right == nodes_along_way[-1]:\n # In non-oneway ways, the above build_data(right, left) call creates the data structure\n # for the final node at the same time as the penultimate one. However, in the case of a\n # oneway path, we have to do it manually:\n nodes[right] = nodes.get(right, {'adjacent': {}})\n\n for node in read_osm_data(nodes_filename):\n id = node['id']\n if id in nodes:\n # If the id of this node in the generator was on a valid way, we add the data about that node\n # to its dictionary in nodes.\n # Add lat/lon data\n nodes[id]['lat'] = node['lat']\n nodes[id]['lon'] = node['lon']\n\n return nodes","def ind_repl(self, dirkey, filekey, txtkey):\n for dir in self.dirs:\n for file in self.get_files(dir):\n self.repl_file(dir, file, dirkey, filekey, txtkey)","def getHierarchy(unique_name):","def getHierarchy(unique_name):","def getHierarchy(unique_name):","def ref_mapping_directory(tmpdir_factory):\n basedir = tmpdir_factory.mktemp('data')\n mapdir = basedir.mkdir('mappings')\n\n template = textwrap.dedent(\"\"\"\n [ molecule ]\n dummy_{0}\n\n [ from ]\n {1}\n\n [ to ]\n {2}\n\n [ atoms ]\n 0 X1{0} A{0} B{0}\n 1 X2{0} C{0} D{0}\n \"\"\")\n\n mappings = collections.defaultdict(lambda: collections.defaultdict(dict))\n\n force_fields_from = ['ff{}'.format(i) for i in range(4)]\n force_fields_to = force_fields_from + ['only_to']\n force_fields_from = force_fields_from + ['only_from']\n iterate_on = itertools.product(force_fields_from, force_fields_to, range(3))\n for idx, (from_ff, to_ff, _) in enumerate(iterate_on):\n mapfile = mapdir / 'file{}.map'.format(idx)\n with open(str(mapfile), 'w') as outfile:\n outfile.write(template.format(idx, from_ff, to_ff))\n\n mapping = {\n (0, 'X1{}'.format(idx)): [(0, 'A{}'.format(idx)), (0, 'B{}'.format(idx))],\n (0, 'X2{}'.format(idx)): [(0, 'C{}'.format(idx)), (0, 'D{}'.format(idx))],\n }\n weights = {\n (0, 'A{}'.format(idx)): {(0, 'X1{}'.format(idx)): 0.5},\n (0, 'B{}'.format(idx)): {(0, 'X1{}'.format(idx)): 0.5},\n (0, 'C{}'.format(idx)): {(0, 'X2{}'.format(idx)): 0.5},\n (0, 'D{}'.format(idx)): {(0, 'X2{}'.format(idx)): 0.5},\n }\n extra = []\n mappings[from_ff][to_ff]['dummy_{}'.format(idx)] = (mapping, weights, extra)\n\n mappings = {from_ff: dict(to_ff) for from_ff, to_ff in mappings.items()}\n\n return Path(str(basedir)), mappings","def content(tmp_loc, ref_names_dict, order):\n \n fl = '[Content_Types].xml'\n inp_path = '/'.join([tmp_loc, fl])\n out_path = '/'.join([output_path, fl])\n \n cnt_lst = []\n asset_lst = []\n def_att = []\n d = dict()\n \n root1,tree1 = gen_tree(inp_path)\n root2,tree2 = gen_tree(out_path)\n \n # get all the extensions belongs to \"Default\" tag\n for relation in root2:\n if 'Default' in relation.tag:\n def_att.append(relation.attrib['Extension'])\n else:\n break\n \n for relation in root1:\n if 'Override' in relation.tag:\n attrib = relation.attrib['PartName'][1:]\n try:\n cnt = attrib.split('ppt/')[-1]\n ini = '/ppt/'\n except:\n cnt = attrib\n ini = '/'\n if cnt in ref_names_dict.keys():\n relation.attrib['PartName'] = f'{ini}{ref_names_dict[cnt]}'\n cnt_lst.append(relation)\n # asset_lst.append(relation.attrib['PartName'])\n else:\n cnt_lst.append(relation)\n if relation.attrib['PartName'] not in asset_lst:\n asset_lst.append(relation.attrib['PartName'])\n else:\n attrib = relation.attrib['Extension']\n if attrib not in def_att:\n cnt_lst.append(relation)\n # asset_lst.append(relation.attrib['Extension'])\n # deal with the assest_lst\n # print(\"AA: \", asset_lst)\n cnt_lst = natsort.natsorted(cnt_lst)\n for ele in cnt_lst:\n prev = tree2.find(ele.tag)\n prev.addnext(ele)\n \n tree2.write(out_path, pretty_print=True, xml_declaration=True, encoding='UTF-8', standalone=True)\n \n unq_attr = []\n for relation in root2:\n if 'Override' in relation.tag:\n if relation.attrib['PartName'] not in unq_attr:\n unq_attr.append(relation.attrib['PartName'])\n else:\n root2.remove(relation)\n tree2.write(out_path, pretty_print=True, xml_declaration=True, encoding='UTF-8', standalone=True)","def processFallbackStageOut():\n\n while True:\n report, node = (yield)\n localReport = {}\n for subnode in node.children:\n if subnode.name in ['phedex-node', 'command', 'option', 'lfn-prefix']:\n localReport[subnode.name] = subnode.attrs.get('value', None)\n report['fallbackStageOut'] = [localReport]","def touched_files(self, parent):","def _analyze(self):\n for _, self.subdirs, files in os.walk(self.path):\n if self.p.sort:\n self.subdirs.sort()\n files.sort()\n for f in files:\n self._analyze_file(fileextlow(f), f)\n break # stop walk() from entering subdirectories\n\n self.p.nr_dirs += 1\n if self.lossless or self.compressed or self.videos:\n if self.lossless or self.compressed:\n if not self.images:\n if self.p.warn_covers:\n print(f\"{W}{self.path}{R}: no cover file\")\n self.p.nr_no_cover += 1\n elif not have_valid_cover_name(self.images):\n if self.p.warn_covers:\n print(f\"{W}{self.path}{R}: wrong cover names\")\n self.p.nr_wrong_cover_name += 1\n if self.lossless:\n if self.compressed:\n self.p.nr_mixed_lossless_compressed += 1\n else:\n self.p.nr_lossless_dirs += 1\n\n if self.cue:\n if not self.lossless:\n if self.p.warn_cue:\n print(f\"{W}{self.path}{R}: cue but no lossless files\")\n self.p.nr_lossy_cue += 1\n elif not self.compressed:\n if len(self.cue) == 1:\n self.p.nr_cue += 1\n else:\n if self.p.warn_cue:\n print(f\"{W}{self.path}{R}: {len(self.cue)} cue files\")\n self.p.nr_multiple_cue += 1\n\n self.p.nr_media_dirs += 1\n self.p.nr_lossless += len(self.lossless)\n self.p.nr_compressed += len(self.compressed)\n self.p.nr_video_files += len(self.videos)\n self.p.nr_ignored += self.ignored\n self.p.unknown.update(self.unknown)\n else:\n if self.images and not self.subdirs:\n self.p.nr_only_images += 1\n else:\n self.p.nr_no_media_dirs += 1","def set_depth(node, depth):\n setattr(node[0], \"depth\", depth)","def showFileTree():\n\treturn 0","def __genAttributesROOT( self, file, indent = ' ' ):\r\n # Go through all actively tracked ASG's (formalisms)\r\n for modelMetaName in self.__trackASG.keys():\r\n if( not self.__isASGbyNameEmpty( modelMetaName ) ):\r\n # This formalism has at least one entity, we NEED IT\r\n ASG = self.getASGbyName( modelMetaName )\r\n \r\n #todo: clean this up\r\n try:\r\n modelTracker = self.__trackAttributes[ modelMetaName ]\r\n except:\r\n print 'ERROR: see ASG.py in __genAttributesROOT(), caused by Buttons Model pointing to a Formalism with a different name'\r\n print 'modelMetaName', modelMetaName \r\n print 'self.__trackAttributes', self.__trackAttributes\r\n print 'self.__trackASG', self.__trackASG\r\n \r\n file.write( '\\n'+indent+'# --- Generating attributes code for ASG '\r\n +modelMetaName+' ---\\n' ) \r\n # DOH! Some formalisms may not have any attributes at all!\r\n if( len( modelTracker ) > 0 ):\r\n file.write( indent + 'if( ' + modelMetaName + 'RootNode ): ' )\r\n i2 = indent + ' '\r\n \r\n #Generates code for the attributes value\r\n for attr in modelTracker.keys():\r\n #print attr, ASG.getAttrValue(attr)\r\n file.write( '\\n'+i2+'# '+attr+'\\n' )\r\n \r\n # Write its value to file\r\n ASG.getAttrValue(attr).writeValue2File ( file = file, indent=i2, \r\n objName = modelMetaName+'RootNode.'+attr, depth = 1,\r\n generatingCode = 0) \r\n else: \r\n file.write( indent+'# No attributes to generate!\\n' )\r\n file.write( indent+'# --- ASG attributes over ---\\n\\n' )","def _save_tree_pickle(self, folderpath):\n\n if not os.path.exists(folderpath):\n raise EnvironmentError('Unable to save pickle file to {}, does not exist'.format(folderpath))\n self.tree.manager = None\n\n picklefile = open(os.path.join(folderpath, \"grid.pickle\"), \"wb\")\n data = {}\n for ky, val in self.__dict__.items():\n if ky not in ['data', 'node_data']:\n data[ky] = val\n pickle.dump(data, picklefile, -1)","def improve_tree(tree, freq_dict):\n # todo","def _fix_other_tree(self, this_tree, other_tree):\n parent_dir, name = osutils.split(self._target_subdir)\n parent_id = this_tree.path2id(parent_dir)\n\n root_ie = other_tree.inventory.root\n root_ie.parent_id = parent_id\n root_ie.name = name\n\n new_file_id = generate_ids.gen_file_id(name)\n trace.mutter('munging root_ie.file_id: %s => %s', root_ie.file_id,\n new_file_id)\n del other_tree.inventory._byid[root_ie.file_id]\n root_ie.file_id = new_file_id\n other_tree.inventory._byid[new_file_id] = root_ie\n # We need to fake a new id for root_ie\n for child_ie in root_ie.children.itervalues():\n child_ie.parent_id = new_file_id","def generate(pref_file, random, out_file=\"tree.obj\"):\n global writer\n writer = ObjWriter(out_file)\n global config\n config = configparser.RawConfigParser()\n global random_en\n random_en = random\n config.read(pref_file)\n _draw_tree(0, config.getfloat(\"params\", \"radius\"), config.getfloat(\"params\", \"length\"), deque([]))\n writer.write_all()\n writer.close()","def initialize_parents(self, filename=None):\n\t\tpass","def first_found_merging(file_names, tree_name):\n\n tree_branches = {}\n for ifile, file_name in enumerate(file_names):\n file_ = uproot.open(file_name)\n if tree_name+\";1\" in file_.keys():\n tree = file_[tree_name].arrays()\n tree_branches = { k: tree[k] for k in tree.fields }\n break\n\n return tree_branches"],"string":"[\n \"def _mutate_file(self, node, visited = set([])):\\n for ch in self._get_children(node):\\n\\n if ch not in visited:\\n visited.add(ch)\\n\\n try:\\n self._mutate_node(ch)\\n except Exception as e:\\n print(e)\\n\\n # Recursion is a bitch\\n self._mutate_file(ch, visited)\",\n \"def _walk(self, level=0):\\n l_dict = self.list_all()\\n indent = level * \\\" \\\"\\n for node in l_dict[\\\"nodes\\\"]:\\n print(indent + \\\"node\\\", node)\\n for group in l_dict[\\\"groups\\\"]:\\n print(indent + \\\"group: \\\", group)\\n with self.open(group) as hdf_group:\\n hdf_group._walk(level=level + 1)\",\n \"def walkthrough(software_map):\\n\\n for i in software_map:\\n\\n if not i[\\\"is_file\\\"]:\\n\\n # for each directory: make a index.md\\n dname = \\\"./docs/\\\" + i[\\\"name\\\"]\\n index = \\\"./docs/\\\" + i[\\\"name\\\"] + \\\"/index.md\\\"\\n print(index)\\n os.mkdir(dname)\\n\\n with open(index, \\\"w+\\\") as f:\\n\\n children = i[\\\"children\\\"]\\n\\n # list files\\n f.write(\\\"Files:\\\\n\\\\n\\\")\\n for i in children:\\n if i[\\\"is_file\\\"]:\\n\\n fname = i[\\\"name\\\"]\\n fext = fname.split(\\\".\\\")\\n if len(fext) == 2:\\n fext = fext[1]\\n else:\\n fext = \\\"none\\\"\\n # for each file, note name and extension\\n f.write(fname + \\\" : \\\" + fext + \\\"\\\\n\\\")\\n\\n # list subdirectories\\n f.write(\\\"\\\\nSubdirectories:\\\\n\\\\n\\\")\\n for i in children:\\n if not i[\\\"is_file\\\"]:\\n\\n dirname = i[\\\"name\\\"]\\n\\n # note the number of files and subdirs in it\\n num_files, num_dirs = 0, 0\\n for child in i[\\\"children\\\"]:\\n if child[\\\"is_file\\\"]:\\n num_files += 1\\n elif not child[\\\"is_file\\\"]:\\n num_dirs += 1\\n\\n # note down name and numbers for each dir\\n f.write(dirname + \\\" : \\\" + str(num_files) + \\\" files, \\\" +\\n str(num_dirs) + \\\" directories\\\\n\\\")\\n\\n # goto subdir\\n if len(i[\\\"children\\\"]) > 0:\\n walkthrough(i[\\\"children\\\"])\",\n \"def save_node(self):\\n # save node in path2node\\n if self.full_path in self.file.path2node:\\n print \\\"** Error, created node with path twice:\\\\n%s\\\" % self.full_path\\n traceback.print_stack()\\n sys.exit(1)\\n self.file.path2node[self.full_path] = self \\n # save node in id_lookups\\n id = self.sdef['id']\\n ns = self.sdef['ns']\\n type = self.sdef['type']\\n custom = 'custom' in self.sdef and self.sdef['custom']\\n if self.parent is None and self.sdef['df'] and not custom:\\n # structure (not custom) created at top level, save in id_lookups\\n if id not in self.file.id_lookups[ns]:\\n print \\\"** Error: Unable to find id '%s' in id_lookups when saving node\\\" % id\\n traceback.print_stack()\\n sys.exit(1)\\n if self.path not in self.file.id_lookups[ns][id]:\\n print (\\\"** Error: Unable to find path '%s' in id_lookups when\\\"\\n \\\" saving node %s\\\") % (self.path, id)\\n print \\\"self.sdef['df'] is:\\\"\\n pp.pprint (self.sdef['df'])\\n traceback.print_stack()\\n sys.exit(1)\\n self.file.id_lookups[ns][id][self.path]['created'].append(self)\\n # save node in all_nodes, either at top level (if no parent) or inside\\n # mstats structure of parent node\\n if self.parent is None:\\n if self.path in self.file.all_nodes:\\n self.file.all_nodes[self.path].append(self)\\n else:\\n self.file.all_nodes[self.path] = [self, ]\\n else:\\n if id not in self.parent.mstats:\\n if custom:\\n # custom node created, add id to mstats of parent\\n self.parent.mstats[id] = { 'df': {}, 'type':type, 'ns': ns,\\n 'created': [ self, ], 'qty':'?' }\\n else:\\n print \\\"** Error: Unable to find key '%s' in parent mstats\\\" % id\\n print \\\"self.parent.mstats is\\\"\\n pp.pprint (self.parent.mstats)\\n traceback.print_stack()\\n sys.exit(1)\\n else: \\n # append node to parent created mstats \\n self.parent.mstats[id]['created'].append(self)\",\n \"def test_modifying_nested_files(self):\\n nested_file = os.path.join(REPO_PATH, 'subdir/nested.txt')\\n with open(nested_file, 'a') as nested:\\n nested.write('nested file stuff')\\n\\n self.result = self.runRegress(\\n ['../resources/modifying_nested_files.sh', 'subdir/nested.txt'],\\n 'all_bad', py_test=False)\\n\\n open(nested_file, 'w').close()\",\n \"def create_rooted_trees_from_dir(paths, fout, outgroup):\\n #pdb.set_trace()\\n fout = open(fout, 'w')\\n for count, path in enumerate(paths):\\n base_path, tree_file_name = os.path.split(path)\\n #pdb.set_trace()\\n fin = open(path)\\n for tree in fin:\\n tree = tree.strip()\\n tree = Tree(tree)\\n tree.set_outgroup(outgroup)\\n newick = tree.write(format=5) + '\\\\n'\\n fout.write(newick)\\n print count+1\\n fout.close()\",\n \"def _build_file_tree(self):\\n # Build file tree with packmode and weigth info (# of file in the packmode)\\n root = {\\\"packmode\\\": None, \\\"weight\\\": None, \\\"children\\\": {}}\\n for filepath, packmode in self.override_packmode_map.items():\\n node = root\\n for part in filepath:\\n node = node[\\\"children\\\"].setdefault(\\n part, {\\\"packmode\\\": None, \\\"weight\\\": None, \\\"children\\\": {}}\\n )\\n node[\\\"weight\\\"] = 1\\n node[\\\"packmode\\\"] = packmode\\n return root\",\n \"def filetree(self) -> P:\\n ...\",\n \"def update_rels(fl_list, tmp_loc, dict_1):\\n old_files = natsort.natsorted([i for i in dict_1.keys()])\\n path = f'{output_path}/ppt'\\n for i in fl_list:\\n root, tree = gen_tree(f'{path}/{i}')\\n for relation in root:\\n attrib = relation.attrib\\n if attrib.get('Target')[3:] in old_files:\\n relation.set('Target', f\\\"../{dict_1[attrib.get('Target')[3:]]}\\\")\\n tree.write(f'{path}/{i}', pretty_print=True, xml_declaration=True, encoding='UTF-8', standalone=True)\\n return\",\n \"def _dfs_assign(self, filetree):\\n stack = [filetree]\\n while stack:\\n node = stack.pop()\\n if isinstance(node, tuple) and node[0][\\\"packmode\\\"] is None:\\n # all children have been seen already, assing packmode\\n node = node[0] # unpack the actual node\\n weights = defaultdict(int)\\n for child in node[\\\"children\\\"].values():\\n weights[child[\\\"packmode\\\"]] += child[\\\"weight\\\"]\\n packmode, weight = max(weights.items(), key=lambda x: x[1])\\n node[\\\"weight\\\"] = weight\\n node[\\\"packmode\\\"] = packmode\\n elif node[\\\"children\\\"]:\\n # schedule that node for computation\\n stack.append((node,))\\n # visit all children first\\n for child in node[\\\"children\\\"].values():\\n stack.append(child)\",\n \"def walk(self, path):\\n # strip trailing slashes, they are not needed\\n path = path.rstrip(os.path.sep)\\n\\n # check if a weight has been provided for this argument\\n weight_adjust, path = check_level(path)\\n\\n if os.path.isfile(path):\\n if self.args.stagger_paths:\\n weight_adjust = weight_adjust + self.stagger\\n new_file = FileObj(path, self.args, self.db,\\n weight_adjust=weight_adjust)\\n if self.args.stagger_paths:\\n self.stagger = self.stagger + new_file.depth\\n self.contents[path] = new_file\\n elif issocket(path):\\n print('WARNING: Skipping a socket ' + path, file=sys.stderr)\\n elif os.path.isdir(path):\\n if self.args.stagger_paths:\\n weight_adjust = weight_adjust + self.stagger\\n top_dir_entry = DirObj(path, self.args, weight_adjust)\\n self.contents[path] = top_dir_entry\\n for dir_name, _, file_list in os.walk(path, topdown=False):\\n # we do not walk into or add names from our ignore list.\\n # We wont delete them if they are leaf nodes and we wont\\n # count them towards parent nodes.\\n if os.path.basename(dir_name) in DELETE_DIR_LIST:\\n continue\\n\\n dir_entry = top_dir_entry.place_dir(\\n dir_name, weight_adjust)\\n if dir_entry is None:\\n continue\\n\\n for fname in file_list:\\n pname = os.path.join(dir_entry.pathname, fname)\\n if issocket(pname):\\n print('WARNING: Skipping a socket ' +\\n pname, file=sys.stderr)\\n elif os.path.basename(fname) not in DELETE_FILE_LIST:\\n new_file = FileObj(fname, self.args, self.db,\\n parent=dir_entry,\\n weight_adjust=weight_adjust)\\n if new_file.bytes == 0 and not self.args.keep_empty_files:\\n new_file.to_delete = True\\n dir_entry.files[fname] = new_file\\n\\n if self.args.stagger_paths:\\n self.stagger = self.stagger + top_dir_entry.max_depth()\\n else:\\n print(\\\"\\\\nFATAL ERROR: dont know what this is: \\\" +\\n path, file=sys.stderr)\\n sys.exit()\",\n \"def get_desired_depth(file_name, tree, desired_depth):\\n node_keys = []\\n get_nodes_at_depth(tree.root, desired_depth, node_keys)\\n generate_file(file_name, node_keys)\\n print(\\\"File '\\\" + file_name + \\\"' generated with keys at depth: :\\\", desired_depth)\",\n \"def traverse(self, filelist, depth=0):\\n if depth > 10:\\n return ['depth > 10']\\n level = {}\\n for entry in (path for path in self.connection.nlst() if path not in ('.', '..')):\\n try:\\n self.connection.cwd(entry)\\n level[entry] = self.traverse(filelist, depth+1)\\n self.connection.cwd('..')\\n except ftplib.error_perm:\\n level[entry] = None\\n return level\",\n \"def updateTree(self):\\n self.reset()\\n self.resetTree() \\n self.read()\",\n \"def createExtnNodes(self):\\n for parent, dirs, files in os.walk(self.destndir):\\n for fname in files:\\n filename = os.path.join(parent, fname)\\n if os.path.isfile(filename):\\n direntry=parent\\n #direntry=parent.replace(self.destndir,'',len(self.destndir))\\n #direntry = os.path.basename(os.path.abspath(parent))\\n self.appendSrcType(direntry, fname)\",\n \"def writeGraph2File(self, file, genGraph=1, isRootNode=0, rootNodeName = \\\"rootNode\\\", \\\\\\r\\n indent=\\\" \\\", genConstraints = 0, fileName = '', genGGcode = 0, parentName=\\\"self\\\", \\\\\\r\\n genImports = 0, depth = 1, nodesToGenList = [] ):\\r\\n\\r\\n # generate code for the nodes...\\r\\n counter =0\\r\\n if( not nodesToGenList ):\\r\\n for nodetype in self.nodeTypes:\\t\\t\\t\\t\\t\\t# iterate on all the node types...\\r\\n for node in self.listNodes[nodetype]:\\t\\t\\t\\t\\t# Iterate on all the nodes of each type\\r\\n node.genAttributesCode(file, genGraph, None, isRootNode, rootNodeName, indent, genConstraints, 1, genGGcode, parentName, genImports, depth + 1 )\\r\\n if self.isSubclass(node, 'ASG'):\\t\\t\\t\\t\\t# if it is a subclass of ASG, ws should include the file generated (hierarchical modeling)\\r\\n newFile = fileName+str(counter)\\r\\n file.write(indent+'exec \\\"from '+newFile+' import '+newFile+'\\\\\\\\n\\\" in self.__dict__, self.__dict__\\\\n')\\r\\n file.write(indent+'self.'+newFile+'(self, self.obj'+str(node.objectNumber)+') \\\\n\\\\n')\\r\\n counter = counter + 1\\r\\n else:\\r\\n for node in nodesToGenList:\\t\\t\\t\\t\\r\\n node.genAttributesCode(file, genGraph, None, isRootNode, rootNodeName, indent, genConstraints, 1, genGGcode, parentName, genImports, depth + 1 )\\r\\n if self.isSubclass(node, 'ASG'):\\t\\t\\t\\t\\t# if it is a subclass of ASG, ws should include the file generated (hierarchical modeling)\\r\\n newFile = fileName+str(counter)\\r\\n file.write(indent+'exec \\\"from '+newFile+' import '+newFile+'\\\\\\\\n\\\" in self.__dict__, self.__dict__\\\\n')\\r\\n file.write(indent+'self.'+newFile+'(self, self.obj'+str(node.objectNumber)+') \\\\n\\\\n')\\r\\n counter = counter + 1\\r\\n \\r\\n \\r\\n # if fileName has a value, we are saving a model, we must generate a function to hold the connections...\\r\\n if fileName != '':\\r\\n # if we are not dealing with a hierarchical model, an extra method is not needed..\\r\\n hierarchical = self.isHierarchical()\\r\\n if hierarchical:\\r\\n file.write('\\\\ndef '+fileName+'_connections(self, rootNode):\\\\n')\\r\\n\\r\\n\\r\\n #-------- Modified by Ximeng Sun / Apr 9,2005 for large conn nums --------\\r\\n file.write('\\\\n')\\r\\n writed = 0\\r\\n # generate code for the connections...\\r\\n if( not nodesToGenList ):\\r\\n for nodetype in self.nodeTypes:\\r\\n for node in self.listNodes[nodetype]:\\r\\n if isRootNode: \\r\\n if(node.__dict__.has_key('name')):\\r\\n debugName = ' named ' + node.name.toString() + '\\\\n'\\r\\n else:\\r\\n debugName = ' of type ' + node.__class__.__name__ + '\\\\n'\\r\\n file.write(indent+'# Connections for obj'+str(node.objectNumber)\\r\\n +' (graphObject_: '+node.graphObject_.tag + ')' + debugName)\\r\\n file.write(indent+'self.drawConnections(\\\\n')\\r\\n res = node.genConnectionsCode(file, genGraph, isRootNode, \\r\\n indent, 1, writed)\\r\\n if isRootNode: \\r\\n file.write(' )\\\\n')\\r\\n else:\\r\\n for node in nodesToGenList:\\r\\n if isRootNode: file.write(indent+'self.drawConnections(')\\r\\n res = node.genConnectionsCode(file, genGraph, isRootNode, indent, 1, \\r\\n writed, nodesToGenList = nodesToGenList)\\r\\n if isRootNode: file.write(' )\\\\n')\\r\\n file.write('\\\\n')\\r\\n #------------ End of modification by Ximeng Sun / Apr 9,2005 -------------\\r\\n \\r\\n \\r\\n # if rootNode and I'm generating a function (filename != '')\\r\\n # then call subModel's functions for connections...\\r\\n if isRootNode and fileName != '': # if main model\\r\\n counter = 0\\r\\n if( not nodesToGenList ):\\r\\n for nodetype in self.nodeTypes: # iterate, to search for all submodels\\r\\n for node in self.listNodes[nodetype]:\\r\\n if self.isSubclass(node, 'ASG'): # found a submodel\\r\\n file.write(indent+'self.'+fileName+str(counter)+'_connections( self, self.obj'+str(node.objectNumber)+')\\\\n')\\r\\n writed = 1\\r\\n counter = counter + 1\\r\\n else:\\r\\n for node in nodesToGenList:\\r\\n if self.isSubclass(node, 'ASG'): # found a submodel\\r\\n file.write(indent+'self.'+fileName+str(counter)+'_connections( self, self.obj'+str(node.objectNumber)+')\\\\n')\\r\\n writed = 1\\r\\n counter = counter + 1\\r\\n \\r\\n \\r\\n if fileName != '' and (not writed) and hierarchical: # we must write 'pass', because nothing has been writed in the function!!\\r\\n file.write(indent+'pass\\\\n')\",\n \"def old_create_dir_struct(self, create_first_rev_folder=\\\"True\\\"):\\n # | - create_dir_struct\\n for job in self.job_var_lst:\\n if create_first_rev_folder == \\\"True\\\":\\n path = self.var_lst_to_path(job) + \\\"_1\\\"\\n elif create_first_rev_folder == \\\"False\\\":\\n path = self.var_lst_to_path(job)\\n\\n path = self.root_dir + \\\"/\\\" + path\\n\\n if os.path.exists(path):\\n mess = \\\"Path already exists: \\\" + str(path)\\n print(mess)\\n\\n elif not os.path.exists(path):\\n os.makedirs(path)\\n\\n # | - Creating Variable Text Files Through Directoy Structure\\n for job in self.job_var_lst:\\n path = self.var_lst_to_path(job)\\n path = self.root_dir + \\\"/\\\" + path\\n\\n file_name = path + \\\"job_dir_level\\\"\\n with open(file_name, \\\"w\\\") as fle:\\n fle.write(\\\"\\\\n\\\")\\n\\n for root, dirs, files in os.walk(self.root_dir + \\\"/data/\\\"):\\n if \\\"job_dir_level\\\" in files:\\n continue\\n\\n else:\\n prop_lst = []\\n for folder in dirs:\\n tmp = self.sep.join(folder.split(self.sep)[1:])\\n\\n prop = self.__replace_p_for_per__(tmp)\\n prop = self.__replace_negative_for_n__(prop)\\n prop_lst.append(prop)\\n\\n for key, value in self.level_entries.items():\\n if set(prop_lst) == set(map(str, value)):\\n\\n file_name = root + \\\"/properties.txt\\\"\\n with open(file_name, \\\"w\\\") as fle:\\n fle.write(key + \\\"\\\\n\\\")\\n\\n # f = open(root + \\\"/properties.txt\\\", \\\"w\\\")\\n # f.write(key + \\\"\\\\n\\\")\\n # f.close()\\n # __|\\n\\n # self.__create_dir_structure_file__()\\n\\n # | - folders_exist attribute should be True from now on\\n file_name = self.root_dir + \\\"/jobs_bin/.folders_exist\\\"\\n with open(file_name, \\\"w\\\") as fle:\\n fle.write(\\\"\\\\n\\\")\\n\\n self.folders_exist = self.__folders_exist__(True)\\n # __|\\n\\n # __|\",\n \"def _update_subfiles(self) -> None:\\n\\t\\t# Clear list of subfiles\\n\\t\\tself.subfiles.clear()\\n\\t\\t# Iterate over Nodes\\n\\t\\tfor node in self.nodes:\\n\\t\\t\\tfor file in node.get_subfiles():\\n\\t\\t\\t\\tself.subfiles.add(\\\"{}/{}\\\".format(self.xml_dir, file))\\n\\t\\t# Iterate over SubNodes\\n\\t\\tfor subnode in self.subnodes:\\n\\t\\t\\tfor file in subnode.filenames:\\n\\t\\t\\t\\tself.subfiles.add(\\\"{}/{}\\\".format(self.xml_dir, file))\",\n \"def save_filter_tree(self,root,good_nodes):\\n date = str(datetime.now())[5:10]\\n filename = \\\"./log/filter_tree_\\\" + date\\n if os.path.isfile(filename):\\n os.remove(filename)\\n if good_nodes == []:\\n with open(filename,\\\"a+\\\") as inp:\\n inp.write(\\\"root\\\\n\\\")\\n else:\\n for node in good_nodes:\\n node.save_node(filename)\\n with open(filename,\\\"a+\\\") as inp:\\n inp.write(\\\"root\\\\n\\\")\\n \\n parent = root\\n curr_node = root.children[0]\\n while True:\\n curr_node.save_node(filename)\\n if curr_node.children == []:\\n while parent.next_child(curr_node) is None:\\n if parent == root and parent.next_child(curr_node) is None:\\n return\\n curr_node = parent\\n parent = curr_node.parent\\n curr_node = parent.next_child(curr_node)\\n else:\\n parent = curr_node\\n curr_node = parent.children[0]\",\n \"def recurse(path):\\n for dirpath, dirnames, filenames in os.walk(path):\\n for filename in filenames:\\n if filename.endswith('.robot'):\\n filepath = os.path.join(dirpath, filename)\\n reformat(filepath)\",\n \"def create_tree(outFile, tree, path='/'):\\n for key, foo in tree.list():\\n if outFile.has_node(path, key):\\n logging.debug('Path already found:', path, key)\\n continue\\n logging.debug('Creating group:', path, key)\\n outFile.create_group(path, key, key)\\n dest = path + key + '/'\\n if outFile.has_node(dest):\\n continue\\n create_tree(outFile, tree.child(key), dest)\",\n \"def __walk_tree(self):\\n for root, dirnames, files in os.walk(self.path, topdown=True):\\n self.dirCount += 1\\n # Create a tuple with the file size, the file name and the files inode (for tracking hard links).\\n files = [\\n (os.lstat(os.path.join(root, fi)).st_size, os.path.join(root, fi), os.lstat(os.path.join(root, fi)).st_ino) for fi\\n in files if (os.lstat(os.path.join(root, fi)).st_size > self.size)]\\n self.fileList.extend(files)\\n if len(self.excludeList) > 0:\\n dirnames[:] = [dir for dir in dirnames if dir not in self.excludeList]\\n if not self.cross_mount_points:\\n dirnames[:] = [dir for dir in dirnames if not os.path.ismount(os.path.join(root, dir))]\",\n \"def makeTree(node,baseName,baseAddress,nodes,parentNode,vars,isGenerated):\\n \\n if (isGenerated == None or isGenerated == False) and node.get('generate') is not None and node.get('generate') == 'true':\\n generateSize = parseInt(node.get('generate_size'))\\n generateAddressStep = parseInt(node.get('generate_address_step'))\\n generateIdxVar = node.get('generate_idx_var')\\n for i in range(0, generateSize):\\n vars[generateIdxVar] = i\\n makeTree(node, baseName, baseAddress + generateAddressStep * i, nodes, parentNode, vars, True)\\n return\\n newNode = Node()\\n name = baseName\\n if baseName != '': name += '.'\\n if node.get('id') is not None:\\n name += node.get('id')\\n name = substituteVars(name, vars)\\n newNode.name = name\\n if node.get('description') is not None:\\n newNode.description = node.get('description')\\n address = baseAddress\\n if node.get('address') is not None:\\n address = baseAddress + parseInt(node.get('address'))\\n newNode.address = address\\n newNode.real_address = (address<<2)+0x64000000\\n newNode.permission = node.get('permission')\\n newNode.mask = parseInt(node.get('mask'))\\n newNode.isModule = node.get('fw_is_module') is not None and node.get('fw_is_module') == 'true'\\n if node.get('sw_monitor_warn_min_threshold') is not None:\\n newNode.warn_min_value = node.get('sw_monitor_warn_min_threshold') \\n if node.get('sw_monitor_error_min_threshold') is not None:\\n newNode.error_min_value = node.get('sw_monitor_error_min_threshold') \\n nodes[name] = newNode\\n if parentNode is not None:\\n parentNode.addChild(newNode)\\n newNode.parent = parentNode\\n newNode.level = parentNode.level+1\\n for child in node:\\n makeTree(child,name,address,nodes,newNode,vars,False)\",\n \"def postOrderMerge(self):\\n\\n seen = {}\\n roots = self.roots()\\n\\n # Run the merge starting at each root. Note that seen\\n # is presisted throughout.\\n for root in roots:\\n self.postOrderMergeHelper(root, seen)\\n\\n # Clean out any dead nodes\\n self.clean()\",\n \"def __create_dir_structure_file__(self):\\n # | - __create_dir_structure_file__\\n\\n dir_structure_data = {}\\n dir_structure_data[\\\"tree_level_labels\\\"] = self.tree_level_labels\\n dir_structure_data[\\\"level_entries_dict\\\"] = self.level_entries_list\\n # TEMP\\n dir_structure_data[\\\"skip_dirs\\\"] = self.skip_dirs_lst\\n\\n fle_name = os.path.join(\\n self.root_dir,\\n self.working_dir,\\n \\\"jobs_bin/dir_structure.json\\\",\\n )\\n\\n with open(fle_name, \\\"w\\\") as fle:\\n json.dump(dir_structure_data, fle, indent=2)\\n # __|\",\n \"def test_checkForOldParents(self):\\n f = open(\\\"Output.txt\\\", \\\"a+\\\")\\n fam: Dict = {'F23':\\n {'fam': 'F23', 'MARR': '14 FEB 1980', 'HUSB': 'I01', 'WIFE': 'I07',\\n 'CHIL': ['I19', 'I26', 'I30']},\\n 'F16': {'fam': 'F16', 'MARR': '12 DEC 2007'}}\\n fam2: Dict = {'F23': {'fam': 'F23', 'MARR': '14 FEB 1980', 'HUSB': 'I01', 'WIFE': 'I07', 'CHIL': ['I19']}}\\n\\n ind1: Dict = {'I01': {'id': 'I01', 'name': 'Joe /Smith/', 'BIRT': '15 JUL 1900', 'sex': 'M', 'family': 'F23',\\n 'DEAT': '31 DEC 2013'},\\n 'I07': {'id': 'I07', 'name': 'Jennifer /Smith/', 'BIRT': '23 SEP 1902', 'sex': 'F',\\n 'family': 'F23',\\n 'DEAT': '31 DEC 2013'},\\n 'I19': {'id': 'I19', 'name': 'Dick /Smith/', 'BIRT': '13 FEB 1999', 'sex': 'M', 'family': 'F23',\\n 'DEAT': '31 DEC 2013'}}\\n\\n ind2: Dict = {'I01': {'id': 'I01', 'name': 'Joe /Smith/', 'BIRT': '15 JUL 1960', 'sex': 'M', 'family': 'F23',\\n 'DEAT': '31 DEC 2013'},\\n 'I07': {'id': 'I07', 'name': 'Jennifer /Smith/', 'BIRT': '23 SEP 1960', 'sex': 'F',\\n 'family': 'F23'},\\n 'I19': {'id': 'I19', 'name': 'Dick /Smith/', 'BIRT': '13 FEB 1981', 'sex': 'M', 'family': 'F23'},\\n 'I26': {'id': 'I26', 'name': 'Jane /Smith/', 'BIRT': '13 FEB 1981', 'sex': 'F', 'family': 'F23'},\\n 'I30': {'id': 'I30', 'name': 'Mary /Test/', 'BIRT': '13 FEB 1981', 'sex': 'F', 'family': 'F23'},\\n 'I32': {'id': 'I32', 'name': 'Nick /Tary/', 'BIRT': '13 FEB 1981', 'sex': 'M', 'family': 'F23'},\\n 'I44': {'id': 'I44', 'name': 'Cersi /Lanister/', 'BIRT': '13 FEB 1981', 'sex': 'F',\\n 'family': 'F23'}}\\n\\n self.assertTrue(us.checkForOldParents(fam, ind2, f))\\n self.assertFalse(us.checkForOldParents(fam2, ind1, f))\",\n \"def convert_treebank(input_dir, output_dir, strategy, subtask):\\n\\n for f in input_dir.iterdir():\\n with open(f, \\\"r\\\") as json_file:\\n docs = json.load(json_file)\\n trees = \\\"\\\"\\n for doc in docs[\\\"docs\\\"]:\\n for sent in doc[\\\"sents\\\"]:\\n graph = sent[\\\"graph\\\"]\\n if strategy == \\\"start\\\":\\n tree = traverse_graph_start(graph)\\n elif strategy == \\\"start-without-pos\\\":\\n tree = traverse_graph_start_without_pos(graph)\\n elif strategy == \\\"end\\\":\\n tree = traverse_graph_end(graph)\\n elif strategy == \\\"end-extra-node\\\":\\n tree = traverse_graph_end_extra_node(graph)\\n elif strategy == \\\"start-end-extra-node\\\":\\n tree = traverse_graph_start_end_extra_node(graph)\\n elif strategy == \\\"start-end-extra-node-heuristic\\\":\\n tree = traverse_graph_start_end_extra_node_heuristic(graph) \\n if subtask:\\n tree = subtask_prune(tree)\\n tree_string = get_string(tree)\\n trees += tree_string + \\\"\\\\n\\\"\\n with open(output_dir.joinpath(f.name).with_suffix(\\\".txt\\\"), \\\"w+\\\") as tree_files:\\n tree_files.write(trees)\",\n \"def write_file_tree(node, header_data, path=None, levels=0):\\n\\n if path is not None:\\n name = os.path.join(path, node.name)\\n else:\\n name = node.name\\n\\n if isinstance(node, pygit2.Blob):\\n return [write_blob(node, header_data, path=path, levels=levels)]\\n\\n if isinstance(node, pygit2.Tree):\\n subnodes = list(\\n itertools.chain.from_iterable(\\n write_file_tree(\\n subnode, header_data, path=name, levels=levels + 1\\n )\\n for subnode in node\\n )\\n )\\n return subnodes\\n\\n return []\",\n \"def file_walker(root,**kwargs):\\n\\n # Get our keyword argunents, and do some initialization.\\n max_depth=kwargs.get('depth',None)\\n if max_depth==None:\\n max_depth=sys.maxsize # I don't think we'll hit this limit in practice.\\n follow_links=kwargs.get('follow_links',True)\\n prune=compile_filename_patterns(kwargs.get('prune',[]))\\n ignore=compile_filename_patterns(kwargs.get('ignore',[]))\\n report_dirs=kwargs.get('report_dirs',False)\\n if report_dirs not in (False,True,'first','last'):\\n raise ValueError(\\\"report_dirs=%r is not one of False, True, 'first', or 'last'.\\\"%(report_dirs,))\\n stack=[(0,root)] # Prime our stack with root (at depth 0).\\n been_there=set([os.path.abspath(os.path.realpath(root))])\\n dir_stack=[] # Stack of paths we're yielding after exhausting those directories.\\n\\n while stack:\\n depth,path=stack.pop()\\n if report_dirs in (True,'first'):\\n yield path+os.sep\\n elif report_dirs=='last':\\n dir_stack.append(path+os.sep)\\n flist=os.listdir(path)\\n flist.sort()\\n dlist=[]\\n # First, let the caller iterate over these filenames.\\n for fn in flist:\\n p=os.path.join(path,fn)\\n if os.path.isdir(p):\\n # Just add this to this path's list of directories for now.\\n dlist.insert(0,fn)\\n continue\\n pat,mat=first_match(fn,ignore)\\n if not pat:\\n yield p\\n # Don't dig deeper than we've been told to.\\n if depth<max_depth:\\n # Now, let's deal with the directories we found.\\n for fn in dlist:\\n p=os.path.join(path,fn)\\n # We might need to stack this path for our fake recursion.\\n if os.path.islink(p) and not follow_links:\\n # Nope. We're not following symlinks.\\n continue\\n rp=os.path.abspath(os.path.realpath(p))\\n if rp in been_there:\\n # Nope. We've already seen this path (and possibly processed it).\\n continue\\n m=None\\n pat,mat=first_match(fn,prune)\\n if pat:\\n # Nope. This directory matches one of the prune patterns.\\n continue\\n # We have a keeper! Record the path and push it onto the stack.\\n been_there.add(rp)\\n stack.append((depth+1,p))\\n while dir_stack:\\n yield dir_stack.pop()\",\n \"def update_tip_names(tree, taxdict):\\n\\n list_nodes = []\\n uniprot_mapping = pd.DataFrame(columns=['taxid', 'name', 'uniprot'])\\n\\n counter = 0\\n for node in tree.traverse(\\\"postorder\\\"):\\n current_name = node.name\\n\\n if 'NMR' in current_name:\\n new_name = \\\"Heterocephalus_glaber\\\"\\n node.name = new_name\\n list_nodes.append(node.name)\\n taxid = \\\"NA\\\" \\n uniprot_mapping.loc[counter] = (taxid, new_name, \\\"UP000006813\\\")\\n counter += 1\\n\\n elif 'Nfurzer' in current_name:\\n new_name = \\\"Nothobranchius_furzeri\\\"\\n node.name = new_name\\n list_nodes.append(node.name)\\n taxid = \\\"NA\\\"\\n uniprot_mapping.loc[counter] = (taxid, new_name, new_name)\\n counter += 1\\n\\n elif 'TAX' in current_name:\\n taxid = current_name[3:].split('x')[0]\\n new_name = taxdict.get(taxid, taxid) \\n node.name = new_name \\n list_nodes.append(node.name)\\n unip = get_uniprot(taxid, accession)\\n uniprot_mapping.loc[counter] = (taxid, new_name, unip)\\n counter += 1\\n\\n\\n \\n tree.write(outfile=\\\"../../data/tree/tree.nw\\\")\\n\\n nodes_df = pd.DataFrame(list_nodes)\\n nodes_df.to_csv(\\\"../../data/tree/tree_list_nodes.txt\\\", index=False, header=False)\\n\\n uniprot_mapping.to_csv(\\\"../../data/tree/tree_uniprot.txt\\\", sep='\\\\t', index=False, header=True)\\n\\n return tree, list_nodes\",\n \"def __gen_hierarchy_file(self, layer):\\n paula_id = '{}.{}.{}_{}'.format(layer, self.corpus_name, self.name,\\n layer)\\n self.paulamap['hierarchy'][layer] = paula_id\\n E, tree = gen_paula_etree(paula_id)\\n\\n dominance_edges = select_edges_by(\\n self.dg, layer=layer, edge_type=EdgeTypes.dominance_relation,\\n data=True)\\n span_edges = select_edges_by(\\n self.dg, layer=layer, edge_type=EdgeTypes.spanning_relation,\\n data=True)\\n dominance_dict = defaultdict(lambda: defaultdict(str))\\n for source_id, target_id, edge_attrs in dominance_edges:\\n if source_id != layer+':root_node':\\n dominance_dict[source_id][target_id] = edge_attrs\\n\\n # in PAULA XML, token spans are also part of the hierarchy\\n for source_id, target_id, edge_attrs in span_edges:\\n if istoken(self.dg, target_id):\\n dominance_dict[source_id][target_id] = edge_attrs\\n\\n # NOTE: we don't add a base file here, because the nodes could be\\n # tokens or structural nodes\\n slist = E('structList', {'type': layer})\\n for source_id in dominance_dict:\\n struct = E('struct',\\n {'id': str(source_id)})\\n if self.human_readable:\\n struct.append(Comment(self.dg.node[source_id].get('label')))\\n\\n for target_id in dominance_dict[source_id]:\\n if istoken(self.dg, target_id):\\n href = '{}.xml#{}'.format(self.paulamap['tokenization'],\\n target_id)\\n else:\\n href = '#{}'.format(target_id)\\n\\n rel = E(\\n 'rel',\\n {'id': 'rel_{}_{}'.format(source_id, target_id),\\n 'type': dominance_dict[source_id][target_id]['edge_type'],\\n XLINKHREF: href})\\n struct.append(rel)\\n if self.human_readable:\\n struct.append(\\n Comment(self.dg.node[target_id].get('label')))\\n slist.append(struct)\\n tree.append(slist)\\n self.files[paula_id] = tree\\n self.file2dtd[paula_id] = PaulaDTDs.struct\\n return paula_id\",\n \"def test_scan_recursive(self):\\n self.run_scan(self.tempdir, self.root_fcount + self.nest_fcount + 1)\",\n \"def _set_level_depth(self, optobj):\\n has_relationship = optobj is not None and 'relationship' in optobj.optional_attrs\\n\\n def _init_level(rec):\\n if rec.level is None:\\n if rec.parents:\\n rec.level = min(_init_level(rec) for rec in rec.parents) + 1\\n else:\\n rec.level = 0\\n return rec.level\\n\\n def _init_depth(rec):\\n if rec.depth is None:\\n if rec.parents:\\n rec.depth = max(_init_depth(rec) for rec in rec.parents) + 1\\n else:\\n rec.depth = 0\\n return rec.depth\\n\\n def _init_reldepth(rec):\\n if not hasattr(rec, 'reldepth'):\\n up_terms = rec.get_goterms_upper()\\n if up_terms:\\n rec.reldepth = max(_init_reldepth(rec) for rec in up_terms) + 1\\n else:\\n rec.reldepth = 0\\n return rec.reldepth\\n\\n for rec in self.values():\\n\\n # Add invert relationships\\n if has_relationship:\\n if rec.depth is None:\\n _init_reldepth(rec)\\n\\n # print(\\\"BBBBBBBBBBB1\\\", rec.id, rec.relationship)\\n #for (typedef, terms) in rec.relationship.items():\\n # invert_typedef = self.typedefs[typedef].inverse_of\\n # # print(\\\"BBBBBBBBBBB2 {} ({}) ({}) ({})\\\".format(\\n # # rec.id, rec.relationship, typedef, invert_typedef))\\n # if invert_typedef:\\n # # Add inverted relationship\\n # for term in terms:\\n # if not hasattr(term, 'relationship'):\\n # term.relationship = defaultdict(set)\\n # term.relationship[invert_typedef].add(rec)\\n # print(\\\"BBBBBBBBBBB3\\\", rec.id, rec.relationship)\\n\\n if rec.level is None:\\n _init_level(rec)\\n\\n if rec.depth is None:\\n _init_depth(rec)\",\n \"def write(self,data): \\n if not os.path.exists(self.output_dir):\\n os.makedirs(self.output_dir)\\n\\n # We will store these in a separate file and link them to the level2s\\n fname = data.filename.split('/')[-1]\\n \\n if os.path.exists(self.outfile):\\n output = h5py.File(self.outfile,'a')\\n else:\\n output = h5py.File(self.outfile,'w')\\n\\n # Set permissions and group\\n if self.set_permissions:\\n try:\\n os.chmod(self.outfile,0o664)\\n shutil.chown(self.outfile, group=self.permissions_group)\\n except PermissionError:\\n self.logger(f'{fname}:{self.name}: Warning, couldnt set the file permissions.')\\n\\n # Store datasets in root\\n data_out = {'tod':self.all_tod,\\n 'weights':self.all_weights,\\n 'mask':self.all_mask,\\n 'cal_factors':self.all_cal_factors,\\n 'frequency':self.all_frequency,\\n 'auto_rms':self.all_auto}\\n\\n for dname, dset in data_out.items():\\n if dname in output:\\n del output[dname]\\n output.create_dataset(dname, data=dset)\\n\\n output.attrs['version'] = __level3_version__\\n output['cal_factors'].attrs['source'] = self.cal_source\\n output['cal_factors'].attrs['calibrator_obsid'] = self.nearest_calibrator\\n\\n output.close()\\n \\n if self.level3 in data.keys():\\n del data[self.level3]\\n data[self.level3] = h5py.ExternalLink(self.outfile,'/')\",\n \"def __load_dir_structure_file__(self):\\n # | - __load_dir_structure_file__\\n try:\\n try:\\n fle_name = self.root_dir + \\\"/jobs_bin/dir_structure.json\\\"\\n\\n with open(fle_name, \\\"r\\\") as dir_struct_f:\\n data = json.load(dir_struct_f)\\n\\n tree_level = data[\\\"tree_level_labels\\\"]\\n level_entries = data[\\\"level_entries_dict\\\"]\\n\\n if \\\"skip_dirs\\\" in data.keys():\\n skip_dirs_lst = data[\\\"skip_dirs\\\"]\\n self.skip_dirs_lst = skip_dirs_lst\\n\\n self.tree_level_labels = tree_level\\n self.level_entries = level_entries\\n self.level_entries_list = level_entries\\n\\n except:\\n print(\\\"Couldn't read /jobs_bin/dir_structure.json\\\")\\n\\n try:\\n\\n # | - __old__\\n tmp = 42\\n # print(\\\"old - Reading dir_structure.json file \\\\\\n # from root_dir\\\")\\n #\\n # fle_name = self.root_dir + \\\"/dir_structure.json\\\"\\n # with open(fle_name, \\\"r\\\") as dir_struct_f:\\n # data = json.load(dir_struct_f)\\n # tree_level = data[\\\"tree_level_labels\\\"]\\n # level_entries = data[\\\"level_entries_dict\\\"]\\n #\\n # if \\\"skip_dirs\\\" in data.keys():\\n # skip_dirs_lst = data[\\\"skip_dirs\\\"]\\n # self.skip_dirs_lst = skip_dirs_lst\\n #\\n # self.tree_level_labels = tree_level\\n # self.level_entries = level_entries\\n # __|\\n\\n except:\\n print(\\\"Couldn't read /dir_structure.json\\\")\\n\\n pass\\n\\n except:\\n mess = \\\"Error opening 'dir_structure.json' file\\\"\\n raise IOError(mess)\\n\\n # __|\",\n \"def generate_tree(self, max_depth = None):\\n\\n if max_depth is None:\\n max_depth = self.tree.max_depth\\n else:\\n max_depth -= 1\\n if max_depth == 0:\\n return\\n self.generate_children()\\n if self.tree.remove:\\n os.unlink(self.source_filename)\\n for child in self.children:\\n if child.count > self.tree.max_count:\\n child.generate_tree(max_depth)\",\n \"def __init__(self, settings):\\n\\n #self.e_tree = settings.e_tree # Don't do this!!!! change all calls to e_tree to self.settings.e_tree!\\n #self.k_tree = settings.k_tree\\n self.settings = settings\\n self.made_parents = {}\\n self.added_files = {}\\n self.edit_files = {}\",\n \"def prettify(tree, indent=0):\\n for key, value in six.iteritems(tree):\\n if key == FILE_MARKER:\\n if value:\\n print((' ' * indent + str(value)))\\n else:\\n print((' ' * indent + str(key)))\\n if isinstance(value, dict):\\n prettify(value, indent+1)\\n else:\\n print((' ' * (indent+1) + str(value)))\",\n \"def __manage_tree(self):\\n for pre, fill, node in RenderTree(self.tree):\\n if node.name is 'count':\\n logger.info(\\n \\\"Tree info %s%s: %s %s p/s attack: %s\\\",\\n pre, node.name, node.value, node.pps, node.attack)\\n else:\\n logger.info(\\\"Pre - [%s], Fill - [%s], Node - [%s]\\\",\\n pre, fill, node.name)\",\n \"def optimized_work_tree(obj, **kwargs):\\n exclusions = kwargs.get('exclusions', {\\\"groups\\\": [], \\\"classes\\\": [], \\\"params\\\": []})\\n groups_done = {}\\n classes = {\\\"depths\\\": {}, \\\"content\\\": {}}\\n params = {\\\"depths\\\": {}, \\\"content\\\": {}}\\n if hasattr(obj, 'hostname') and not hasattr(obj, 'name'):\\n obj.name = obj.hostname\\n to_index = [(obj, 1)]\\n\\n index_pop = to_index.pop\\n index_extend = to_index.extend\\n while to_index:\\n (obj, depth) = index_pop()\\n objname = obj.name\\n if objname in groups_done and groups_done[objname] <= depth:\\n continue\\n\\n objclasses = obj.classes.exclude(classname__in=exclusions['classes'])\\n updated_classes = optimized_update_values(objclasses, \\\"classname\\\", \\\"classparams\\\", depth=depth, results=classes)\\n\\n objparams = obj.parameters.exclude(paramkey__in=exclusions['params'])\\n updated_params = optimized_update_values(objparams, \\\"paramkey\\\", \\\"paramvalue\\\", depth=depth, results=params)\\n\\n if not updated_classes or not updated_params:\\n return (\\\"Fail\\\", \\\"Fail\\\")\\n\\n groups_done[objname] = depth\\n depth += 1\\n children = ((group, depth) for group in obj.groups.exclude(name__in=exclusions['groups']))\\n index_extend(children)\\n\\n params['content']['done_count'] = len(groups_done)\\n return (classes[\\\"content\\\"], params[\\\"content\\\"])\",\n \"def traverse_tree(file, tree):\\n\\n\\tfor node in tree.get_children():\\n\\t\\tpass\",\n \"def _dfs_postorder(node, visited):\\n\\t# print(\\\"_dfs_postorder\\\")\\n\\tif node.lo is not None:\\n\\t\\tyield from _dfs_postorder(node.lo, visited)\\n\\tif node.hi is not None:\\n\\t\\tyield from _dfs_postorder(node.hi, visited)\\n\\tif node not in visited:\\n\\t\\tvisited.add(node)\\n\\t\\tyield node\",\n \"def test_hierarchies(self):\\n compare_file_hierarchy(self, file_hierarchy(self.file_hierarchy_dict))\",\n \"def main():\\n\\n ''' Reading the training data file '''\\n original_training_data = pd.read_csv(\\\"DT_Data_CakeVsMuffin_v012_TRAIN.csv\\\")\\n\\n ''' Storing the final decision tree '''\\n final_tree = decision_tree(original_training_data,0)\\n\\n ''' Printing the final decision tree '''\\n print(\\\"This is the resulting decision tree: \\\\n\\\")\\n print(final_tree)\\n\\n ''' Iterating through the dictionary by using the key values '''\\n for key in final_tree.keys():\\n ''' Parent = Flour <= 5.1636'''\\n parent = key\\n ''' left_child = [{'Oils <= 3.1265': [{'Flour <= 2.7291': [{'Proteins <= 2.6527': ['Muffin', 'CupCake']}, 'Muffin']}, 'CupCake']}'''\\n left_child = final_tree[parent][0]\\n ''' right_child = {'Oils <= 7.7793': ['Muffin', {'Flour <= 8.2225': ['CupCake', 'Muffin']}]}]'''\\n right_child = final_tree[parent][1]\\n\\n ''' Writing a file which generates code for classification '''\\n file = open('HW06_Parchand_Nihal_Classifier.py','w+')\\n file.write(\\\"'''Importing libraries''' \\\"\\n \\\"\\\\n\\\\nimport pandas as pd \\\\n\\\\ndef main():\\\"\\n \\\"\\\\n\\\\tdata_df = pd.read_csv('DT_Data_CakeVsMuffin_v012_TEST.csv')\\\"\\n \\\"\\\\n\\\\tresult = []\\\"\\n \\\"\\\\n\\\\tfor row in range(0,len(data_df)):\\\"\\n \\\"\\\\n\\\\t\\\\tFlour = data_df.loc[row][0]\\\"\\n \\\"\\\\n\\\\t\\\\tSugar = data_df.loc[row][1]\\\"\\n \\\"\\\\n\\\\t\\\\tOils = data_df.loc[row][2]\\\"\\n \\\"\\\\n\\\\t\\\\tProteins = data_df.loc[row][3]\\\"\\n \\\"\\\\n\\\\t\\\\tif {}:\\\\n\\\".format(parent))\\n\\n ''' Iterating through the left_tree '''\\n for key in left_child.keys():\\n file.write(\\\"\\\\t\\\\t\\\\tif {}:\\\\n\\\".format(key))\\n\\n ''' Iterating through the inner left_tree '''\\n for inner_key in left_child[key][0].keys():\\n file.write(\\\"\\\\t\\\\t\\\\t\\\\tif {}:\\\\n\\\".format(inner_key))\\n\\n for inner_inner_key in ((left_child[key][0])[inner_key])[0]:\\n file.write(\\\"\\\\t\\\\t\\\\t\\\\t\\\\tif {}:\\\\n\\\".format(inner_inner_key))\\n file.write(\\\"\\\\t\\\\t\\\\t\\\\t\\\\t\\\\tresult.append(0)\\\\n\\\")\\n file.write(\\\"\\\\t\\\\t\\\\t\\\\t\\\\telse:\\\\n\\\".format(inner_inner_key))\\n file.write(\\\"\\\\t\\\\t\\\\t\\\\t\\\\t\\\\tresult.append(1)\\\\n\\\")\\n\\n file.write(\\\"\\\\t\\\\t\\\\t\\\\telse:\\\\n\\\")\\n file.write(\\\"\\\\t\\\\t\\\\t\\\\t\\\\tresult.append(0)\\\\n\\\")\\n file.write(\\\"\\\\t\\\\t\\\\telse:\\\\n\\\")\\n file.write(\\\"\\\\t\\\\t\\\\t\\\\tresult.append(1)\\\\n\\\")\\n file.write(\\\"\\\\t\\\\telse:\\\\n\\\")\\n\\n ''' Iterating through the right_tree '''\\n for key in right_child.keys():\\n file.write(\\\"\\\\t\\\\t\\\\tif {}:\\\\n\\\".format(key))\\n file.write(\\\"\\\\t\\\\t\\\\t\\\\tresult.append(0)\\\\n\\\")\\n for inner_key in right_child[key][1].keys():\\n file.write(\\\"\\\\t\\\\t\\\\telif {}:\\\\n\\\".format(inner_key))\\n file.write(\\\"\\\\t\\\\t\\\\t\\\\tresult.append(1)\\\\n\\\")\\n file.write(\\\"\\\\t\\\\t\\\\telse:\\\\n\\\")\\n file.write(\\\"\\\\t\\\\t\\\\t\\\\tresult.append(0)\\\\n\\\\n\\\")\\n\\n ''' Writing the results of classifier to a csv file '''\\n file.write(\\n \\\"\\\\twith open('HW06_Parchand_Nihal_MyClassifications.csv', 'w+') as file2:\\\\n\\\"\\n \\\"\\\\t\\\\tfor value in result:\\\\n\\\"\\n \\\"\\\\t\\\\t\\\\tfile2.write(str(value))\\\\n\\\"\\n \\\"\\\\t\\\\t\\\\tfile2.write('\\\\\\\\n')\\\\n\\\\n\\\"\\n \\\"main()\\\")\",\n \"def _walk_dirs(self):\\n for project_name in self.new_source_paths.keys():\\n # print \\\"-------- Now mapping ---- \\\" + project_name\\n search_path = self.root + project_name + '\\\\\\\\Data'\\n for dirpath, subdirs, files in os.walk(search_path):\\n for file in files:\\n self.new_source_paths[project_name][file] = dirpath\\n # print \\\"------------ Finished mapping ------- \\\" + project_name\\n return self.new_source_paths\",\n \"def _trickle_up(im, node, parents, merge, depth):\\n\\n n, x, y = node.n, node.x, node.y\\n\\n pth = os.path.join('%i' % n, '%i' % y, '%i_%i.png' % (y, x))\\n\\n nparent = sum(len(v) for v in parents.values())\\n assert nparent <= 4 * max(depth, 1)\\n\\n if depth >= n: # handle special case of depth=0, n=1\\n yield pth, im\\n\\n if n == 0:\\n return\\n\\n # - If not merging and not at level 1, no need to accumulate\\n if not merge and n > 1:\\n return\\n\\n parent, xc, yc = _parent(node)\\n corners = parents[parent]\\n corners[(xc, yc)] = im\\n\\n if len(corners) < 4: # parent not yet ready\\n return\\n\\n parents.pop(parent)\\n ul = corners[(0, 0)]\\n ur = corners[(1, 0)]\\n bl = corners[(0, 1)]\\n br = corners[(1, 1)]\\n mosaic = np.vstack((np.hstack((ul, ur)), np.hstack((bl, br))))\\n im = (merge or _default_merge)(mosaic)\\n\\n for item in _trickle_up(im, parent, parents, merge, depth):\\n yield item\",\n \"def do_all_the_things(data):\\n \\n os.mkdir('./temp-blocks')\\n for block in data:\\n if not os.path.exists('./pages/index.css'):\\n write.imports_to_index(block)\\n declarations = read.get_declaration_blocks(block)\\n\\n elems_and_mods = data[block]\\n if elems_and_mods:\\n for elem_or_mod in elems_and_mods:\\n if elem_or_mod.startswith('__'):\\n build_elem_file_structure(block, elem_or_mod, data, \\n declarations)\\n else:\\n build_mod_file_structure(block, elem_or_mod, data, \\n declarations, isBlock=True)\\n\\n rewrite_block_css_files(block, data, declarations) \\n os.rmdir('./temp-blocks')\",\n \"def update_level(self):\\n level = 1\\n assigned_levels = set([])\\n just_assigned = set([])\\n for root in self.roots:\\n for child in root.children:\\n if child in just_assigned:\\n continue\\n child.level = level\\n if len(child.children) == 0:\\n continue\\n just_assigned.add(child)\\n assigned_levels = assigned_levels.union(just_assigned)\\n\\n level += 1\\n leaves = [c for c in self.collectors if len(c.children) == 0]\\n len_non_leaves = len(self.collectors) - len(leaves)\\n self.update_level_for_non_leaves(\\n level, assigned_levels, just_assigned, len_non_leaves\\n )\",\n \"def reaching_definitions(self):\\n dirty = True\\n while dirty:\\n dirty = False\\n for block in self.blocks:\\n i_input = 0\\n for parent in block.parents:\\n i_input |= parent.i_output\\n i_output = (i_input & ~block.i_kill) | block.i_gen\\n if i_output != block.i_output:\\n dirty = True\\n block.i_input = i_input\\n block.i_output = i_output\",\n \"def reaching_definitions(self):\\n dirty = True\\n while dirty:\\n dirty = False\\n for block in self.blocks:\\n i_input = 0\\n for parent in block.parents:\\n i_input |= parent.i_output\\n i_output = (i_input & ~block.i_kill) | block.i_gen\\n if i_output != block.i_output:\\n dirty = True\\n block.i_input = i_input\\n block.i_output = i_output\",\n \"def post_ancestry(self, ancestry):\\n raise NotImplementedError(\\\"Implement in sub classes\\\")\",\n \"def traverseTree(mdsnode,dead_branches=False,depth=float('Nan'),current_depth=0,noisy=False,strict=False,tags=False):\\n tagdict={}\\n if isinstance(mdsnode,mds.tree.Tree): \\n mdsnode=mdsnode.getNode(\\\"\\\\\\\\TOP\\\")\\n \\n name = get_mds_shortname(mdsnode) \\n me = Branch(mdsnode)#put node information here if you like\\n if noisy: print (\\\" \\\"*current_depth + name)\\n\\n #Members are data/signals, put them directly the current Node object\\n #if they are arrays\\n if mdsnode.getNumMembers()>0:\\n leaves=mdsnode.getMembers()\\n for leaf in leaves:\\n leafname=get_mds_shortname(leaf)\\n leafshape=get_mds_shape(leaf)\\n if dead_branches or not len(leafshape) ==0:\\n if noisy: print (\\\" \\\"*(current_depth+1) + leafname +\\\": array%s\\\"%str(leafshape))\\n setattr(me,leafname,Leaf(leaf,strict))\\n tagdict[leafname]=getattr(me,leafname)\\n else:\\n if noisy: print(\\\" \\\"*(current_depth+1) + leafname)\\n #Children contain no immediate data, just links to more nodes. If depth is\\n #not beyond limit, go down these 'branches' and add contents to the current\\n #Node object\\n if not depth <= current_depth and mdsnode.getNumChildren()>0:\\n branches = mdsnode.getChildren()\\n for b in branches:\\n subname,subnode,subtags=traverseTree(b, dead_branches,depth,current_depth+1,noisy,strict)\\n if len(subnode.__getDescendants__())>0:\\n setattr(me,subname,subnode)\\n tagdict[subname]=getattr(me,subname)\\n for k,v in subtags.items(): #merge tags in\\n tagdict[k]=v\\n \\n if current_depth==0:#we are done, returning to user\\n if tags: \\n for tag,obj in tagdict.items():\\n setattr(me,tag,obj)\\n else:\\n tagbranch=Branch(mdsnode)\\n for tag,obj in tagdict.items():\\n setattr(tagbranch,tag,obj)\\n setattr(me,'tags',tagbranch) \\n return me\\n return (name, me,tagdict) #else, we are still recursing back down the tree\",\n \"def dfs_postorder(self):\\n\\t\\t# print(\\\"Class BinaryDecisionDiagram _dfs_postorder\\\")\\n\\t\\tyield from _dfs_postorder(self.node, set())\",\n \"def set_depth(self):\\n if self.depth != None:\\n return\\n if not self.parents:\\n self.depth = 0\\n return\\n for parent in self.parents:\\n parent.set_depth()\\n \\n depths = [parent.depth for parent in self.parents]\\n self.depth = max(depths) + 1\",\n \"def walk_files():\\n\\n # TODO: not check twice the same dir or file\\n for path in config.targets:\\n abs_path = os.path.join(cwd, path)\\n\\n if not os.path.islink(abs_path) and os.path.isfile(abs_path):\\n walked.append(abs_path)\\n yield abs_path\\n #process_file(abs_path)\\n\\n if os.path.isdir(abs_path):\\n walked.append(abs_path)\\n for root, dirs, files in os.walk(abs_path):\\n for fname in files:\\n if isbackup(fname):\\n continue\\n abs_path = os.path.join(root, fname)\\n walked.append(abs_path)\\n if not os.path.islink(abs_path) and\\\\\\n os.path.isfile(abs_path):\\n base, name = os.path.split(abs_path)\\n XXX, ext = os.path.splitext(name)\\n\\n ignored = False\\n for pattern in IGNORE_FILES:\\n if pattern.search(fname):\\n ignored = True\\n break\\n\\n # maybe should be merged with IGNORE_FILES?\\n for regexp in config.exclude_list:\\n if regexp.search(fname):\\n ignored = True\\n break\\n\\n if not ignored:\\n for test_ext in config.disallow_exts:\\n if test_ext == ext:\\n ignored = True\\n break\\n\\n if not ignored:\\n if config.allow_exts:\\n ignored = True\\n for test_ext in config.allow_exts:\\n if test_ext == ext:\\n ignored = False\\n break\\n\\n if not ignored:\\n yield abs_path\\n #process_file(abs_path)\\n\\n for dir in dirs[:]:\\n if dir in IGNORE_DIRS:\\n dirs.remove(dir)\\n if dir in dirs:\\n dirs.remove(dir)\\n # mayb be should be merged with IGNORE_DIRS?\\n else:\\n for regexp in config.exclude_list:\\n if regexp.search(dir):\\n # This check is required\\n # because several different patterns\\n # could match one file name\\n if dir in dirs:\\n dirs.remove(dir)\\n\\n for dir in dirs:\\n abs_path = os.path.join(root, dir)\\n walked.append(abs_path)\",\n \"def WriteVmInfo(vm, depth=1):\\n #print('ModelSay.py - Writing VMs to Graph')\\n maxdepth = 10\\n global folder\\n # if this is a group it will have children. if it does, recurse into them\\n # and then return\\n if hasattr(vm, 'childEntity'):\\n if depth > maxdepth:\\n return\\n #print('VM Folder: %s' % vm.name)\\n\\n #global folder \\n folder = vm.name\\n vmList = vm.childEntity\\n for c in vmList:\\n WriteVmInfo(c, depth+1)\\n return\\n\\n vm_node = BuildNode(vm)\",\n \"def set_global_properties(self, validate=False):\\n # Tree num array\\n self.treenum_arr = np.zeros(self.totnhalos, dtype='int64')\\n start = self.nhalos_before_tree\\n stop = start + self.nhalos_per_tree\\n for t in range(self.ntrees):\\n self.treenum_arr[start[t]:stop[t]] = t\\n # Memmap/file object\\n self.fobj = np.memmap(self.filename, dtype=self.item_dtype, mode='c',\\n offset=self.header_size)\\n # Read all data\\n data = self.read_all_trees(skip_add_fields=True, validate=validate)\\n # File number\\n self.filenum = data['FileNr'][0]\\n if (data['SnapNum'][0] + 1) != len(self.scale_factors): # pragma: no cover\\n ytreeLogger.warning(\\n f\\\"First FoF central is in snapshot {data['SnapNum'][0] + 1}/{len(self.scale_factors)}.\\\")\\n # Halo unique IDs\\n self.all_uids = np.bitwise_or(\\n np.int64(self.filenum) << 32, np.arange(self.totnhalos, dtype='int64'))\\n # Get descendant unique IDs\\n desc = data['Descendant']\\n pos_flag = (desc >= 0)\\n desc_uid = np.zeros(self.totnhalos, dtype='int64') - 1\\n desc_abs = self.get_total_index(self.treenum_arr, desc)\\n desc_uid[pos_flag] = self.all_uids[desc_abs[pos_flag]]\\n self.all_desc_uids = desc_uid\\n # Add fields and cache root fields\\n data = self.add_computed_fields(-1, data, validate=validate)\\n root_idx = self.nhalos_before_tree\\n self._root_data = dict()\\n for k in self.fields:\\n self._root_data[k] = data[k][root_idx]\",\n \"def generate_tree_postorder(node_lst, root_index):\",\n \"def _WalkFolders(self, folder_dict, parent):\\n entries = folder_dict.keys()\\n entries.sort()\\n for e in entries:\\n if folder_dict[e]:\\n # Folder\\n n_subfolder = self.doc.createElement('Filter')\\n n_subfolder.setAttribute('Name', e)\\n parent.appendChild(n_subfolder)\\n self._WalkFolders(folder_dict[e], n_subfolder)\\n else:\\n # File\\n n_file = self.doc.createElement('File')\\n n_file.setAttribute('RelativePath', e)\\n parent.appendChild(n_file)\",\n \"def save_to_temp(obj, file_name, xml_file, node, hash_id, routine=\\\"temp_file\\\"):\\n root = xml_file.getroot()\\n try:\\n output = root.find(\\\"saved_files\\\").attrib[\\\"path\\\"]\\n except KeyError:\\n output = None\\n if output is not None:\\n dir_name = output\\n else:\\n dir_name = os.path.dirname(file_name)\\n parent_name = os.path.basename(dir_name)\\n print(\\\"Saving \\\" + routine + \\\" to file\\\")\\n print(\\\"Output folder: \\\" + dir_name)\\n model_name = root.attrib['name']\\n save_folder = \\\"/saved_files/\\\" + routine +\\\"-\\\"+model_name+ \\\"_\\\" +str(hash_id)+ \\\".bp\\\"\\n\\n filename = dir_name+save_folder\\n\\n relative_path=dir_name+save_folder\\n if not os.path.isdir(dir_name+\\\"/saved_images\\\"):\\n os.mkdir(dir_name+\\\"/saved_images\\\")\\n for i in plt.get_fignums():\\n if i not in saved_already:\\n saved_already.append(i)\\n Plotting.figure(i)\\n save_image_folder = '/saved_images/'+routine+\\\"-\\\"+model_name+'-figure%d.png' % i\\n Plotting.savefig(dir_name+save_image_folder)\\n try:\\n Utility.save(obj, filename)\\n except IOError:\\n os.mkdir(dir_name+\\\"/saved_files/\\\")\\n Utility.save(obj, filename)\\n node.set('path', relative_path)\\n root = xml_file.getroot()\\n indent(root)\\n xml_file.write(file_name)\",\n \"def set_depth(self, d):\\r\\n self.depth = d\",\n \"def _fixupChildren(self, ph, alogger):\\n name = alogger.name\\n namelen = len(name)\\n for c in ph.loggerMap.keys():\\n #The if means ... if not c.parent.name.startswith(nm)\\n if c.parent.name[:namelen] != name:\\n alogger.parent = c.parent\\n c.parent = alogger\",\n \"def create_recursive(replace_dict, step_index, directories, dependency_level, keys=[]):\\n\\n # check if we are at the lowest level\\n if step_index == len(steps):\\n # create a call and execute it\\n if check_requirements(replace_dict):\\n execute_dependent_task(create_command_line(replace_dict), directories, dependency_level)\\n else:\\n if steps[step_index] not in directories:\\n directories[steps[step_index]] = []\\n\\n # we are at another level\\n if steps[step_index] not in configuration.replace.keys():\\n # nothing to be replaced here, so just go to the next level\\n create_recursive(replace_dict, step_index+1, directories, dependency_level)\\n else:\\n # iterate through the keys\\n if keys == []:\\n # call this function recursively by defining the set of keys that we need\\n create_recursive(replace_dict, step_index, directories, dependency_level, keys = sorted(configuration.replace[steps[step_index]].keys()))\\n else:\\n # create a deep copy of the replacement dict to be able to modify it\\n replace_dict_copy = copy.deepcopy(replace_dict)\\n directories_copy = copy.deepcopy(directories)\\n # iterate over all replacements for the first of the keys\\n key = keys[0]\\n replacement_directories = sorted(configuration.replace[steps[step_index]][key])\\n directories_copy[steps[step_index]].append(\\\"\\\")\\n new_dependency_level = dependency_level\\n for replacement_index in range(len(replacement_directories)):\\n # increase the counter of the current replacement\\n replace_dict_copy[key] = replacement_index\\n directories_copy[steps[step_index]][-1] = replacement_directories[replacement_index]\\n # call the function recursively\\n if len(keys) == 1:\\n # we have to go to the next level\\n create_recursive(replace_dict_copy, step_index+1, directories_copy, new_dependency_level)\\n else:\\n # we have to subtract the keys\\n create_recursive(replace_dict_copy, step_index, directories_copy, new_dependency_level, keys = keys[1:])\\n new_dependency_level = step_index\",\n \"def reconstruct_ancestry(self, parent_ancestry):\\n self._construct_ancestry(parent_ancestry)\\n for flag in self.flags:\\n flag.reconstruct_ancestry(self.ancestry)\",\n \"def _initialize_trees(self):\",\n \"def preRead(force,cat,path,depth = 0,retries = 0):\\n limit = 6 # Lower limit for printing debug messages in this function\\n root = None\\n if cat == 'p':\\n global people\\n root = people\\n elif cat == 'l':\\n global places\\n root = places\\n elif cat == 'c':\\n global cities\\n root = cities\\n elif cat == 's':\\n global states\\n root = states\\n elif cat == 'o':\\n global orgs\\n root = orgs\\n elif cat == 'i':\\n global items\\n root = items\\n else:\\n print \\\"ERR: Invalid category %s passed to markChanged.\\\" % cat\\n if not root:\\n print \\\"preRead: Invalid category %s?\\\" % cat\\n return False\\n if depth > len(path): depth = len(path)\\n if depth > 7: depth = 7\\n if path[0] in root.keys():\\n if depth <= 1:\\n return True\\n if path[1] in root[path[0]].keys():\\n if depth <= 2:\\n return True\\n if path[2] in root[path[0]][path[1]].keys():\\n if depth <= 3:\\n return True\\n if path[3] in root[path[0]][path[1]][path[2]].keys():\\n if depth <= 4:\\n return True\\n if path[4] in root[path[0]][path[1]][path[2]][path[3]].keys():\\n if depth <= 5:\\n return True\\n if path[5] in root[path[0]][path[1]][path[2]][path[3]][path[4]].keys():\\n if depth <= 6:\\n return True\\n if path[6] in root[path[0]][path[1]][path[2]][path[3]][path[4]][path[5]].keys():\\n return True # Maximum depth reached\\n elif force:\\n root[path[0]][path[1]][path[2]][path[3]][path[4]][path[5]][path[6]] = {}\\n if retries >= depth: force = False\\n return preRead(force,cat,path,depth,retries + 1)\\n else: # Not found, and not forcing it to be found\\n if config['debug'] > limit: debugPath(root,path)\\n return False\\n elif force:\\n root[path[0]][path[1]][path[2]][path[3]][path[4]][path[5]] = {}\\n if retries >= depth: force = False\\n return preRead(force,cat,path,depth,retries + 1)\\n else: # Not found, and not forcing it to be found\\n if config['debug'] > limit: debugPath(root,path)\\n return False\\n elif force:\\n root[path[0]][path[1]][path[2]][path[3]][path[4]] = {}\\n if retries >= depth: force = False\\n return preRead(force,cat,path,depth,retries + 1)\\n else: # Not found, and not forcing it to be found\\n if config['debug'] > limit: debugPath(root,path)\\n return False\\n elif force:\\n root[path[0]][path[1]][path[2]][path[3]] = {}\\n if retries >= depth: force = False\\n return preRead(force,cat,path,depth,retries + 1)\\n else: # Not found, and not forcing it to be found\\n if config['debug'] > limit: debugPath(root,path)\\n return False\\n elif force:\\n root[path[0]][path[1]][path[2]] = {}\\n if retries >= depth: force = False\\n return preRead(force,cat,path,depth,retries + 1)\\n else: # Not found, and not forcing it to be found\\n if config['debug'] > limit: debugPath(root,path)\\n return False\\n elif force:\\n root[path[0]][path[1]] = {}\\n if retries >= depth: force = False\\n return preRead(force,cat,path,depth,retries + 1)\\n else: # Not found, and not forcing it to be found\\n if config['debug'] > limit: debugPath(root,path)\\n return False\\n else: # First level (fileid) can't be generated.\\n if config['debug'] > limit: debugPath(root,path)\\n return False\",\n \"def dfsHelper(self, root, nodes):\\n if root.id > 0:\\n nodes[root.id] = root\\n\\n for neighbor in root.neighbors:\\n self.dfsHelper(neighbor, nodes)\",\n \"def test_nested_settings_files(tmpdir):\\n subfolder = tmpdir.mkdir(\\\"sub\\\")\\n p = subfolder.join(\\\"settings.json\\\")\\n nested_1_p = subfolder.join(\\\"nested_1.json\\\")\\n nested_2_p = subfolder.join(\\\"nested_2.json\\\")\\n\\n nested_2_p.write(json.dumps({\\\"foo\\\": 1, \\\"bar\\\": 2}))\\n nested_1_p.write(json.dumps({\\\"level_2_from_file\\\": str(nested_2_p)}))\\n p.write(\\n json.dumps(\\n {\\n \\\"level_1_from_file\\\": str(\\n nested_1_p\\n ), # nested_1_p references nested_2_p internally.\\n \\\"spam\\\": \\\"parrot\\\",\\n \\\"list\\\": [\\n \\\"random\\\",\\n {\\n \\\"this_from_file\\\": str(\\n nested_2_p\\n ) # dictionaries in lists should be expanded as well.\\n },\\n ],\\n }\\n )\\n )\\n\\n climate = core.Climate(prefix=\\\"TEST_STUFF\\\", settings_files=[str(p)])\\n assert dict(climate.settings) == {\\n \\\"spam\\\": \\\"parrot\\\",\\n \\\"level_1\\\": {\\\"level_2\\\": {\\\"foo\\\": 1, \\\"bar\\\": 2}},\\n \\\"list\\\": [\\\"random\\\", {\\\"this\\\": {\\\"foo\\\": 1, \\\"bar\\\": 2}}],\\n }\",\n \"def iter_dir(tree, path):\\n for f in os.listdir(path):\\n if os.path.isfile(path + '/' + f + '/__init__.py'):\\n tree[f] = None\\n elif os.path.isdir(path + '/' + f):\\n tree[f] = {}\\n SnakeWM.iter_dir(tree[f], path + '/' + f)\",\n \"def write_map( file_lists, target_dir, output_dir ):\\n tld_to_volumes = {}\\n for i, group in enumerate( file_lists ):\\n for node in group:\\n tld = toplevel_subdir( node, target_dir )\\n tld_to_volumes.setdefault( tld, set() ).add( i )\\n with open( os.path.join( output_dir, \\\"map.txt\\\" ), \\\"w\\\" ) as fout:\\n for tld, volumes in tld_to_volumes.items():\\n fout.write( \\\"{:24s}: {}\\\\n\\\".format( tld, \\\" \\\".join( [ str( x ) for x in volumes ] ) ) )\",\n \"def test_level2_recursion(self):\\n recursed = recurse_files('filename2', self.files['filename2'], self.files)\\n self.assertEqual(recursed, [\\\"file7\\\", \\\"file2\\\", \\\"file3\\\", \\\"file6\\\"])\",\n \"def _set_path(self):\\n self.path = self._get_path()\\n self.depth = self.get_depth()\\n\\n self.save()\",\n \"def atree(dir,\\n print_files=True,\\n outfile=None):\\n\\n nodes = dict()\\n nodes[dir] = Node(dir)\\n root_node = nodes[dir]\\n for root, dirs, files in os.walk(dir, topdown=True):\\n if root not in nodes:\\n nodes[root] = Node(root)\\n for name in files:\\n if print_files:\\n nodes[os.path.join(root, name)] = \\\\\\n Node(name, parent=nodes[root])\\n for name in dirs:\\n nodes[os.path.join(root, name)] = Node(name, parent=nodes[root])\\n\\n output = []\\n for pre, fill, node in RenderTree(root_node):\\n output.append((f'{ pre }{ node.name }'))\\n if outfile is not None:\\n for line in output:\\n print(line, file=outfile)\\n else:\\n return output\",\n \"def Init(self):\\n # First iteration over all the files in root searching for symlinks and\\n # non-regular files.\\n seen_inodes = {}\\n for basepath, _, filenames in sorted(os.walk(self._root)):\\n for filename in sorted(filenames):\\n full_path = os.path.join(basepath, filename)\\n rel_path = full_path[len(self._root):]\\n st = os.lstat(full_path)\\n\\n file_data = {\\n 'size': st.st_size,\\n }\\n self._files[rel_path] = file_data\\n\\n # Track symlinks.\\n if stat.S_ISLNK(st.st_mode):\\n link_path = os.readlink(full_path)\\n # lddtree's normpath handles a little more cases than the os.path\\n # version. In particular, it handles the '//' case.\\n self._symlinks[rel_path] = (\\n link_path.lstrip('/') if link_path and link_path[0] == '/' else\\n lddtree.normpath(os.path.join(os.path.dirname(rel_path),\\n link_path)))\\n file_data['deps'] = {\\n 'symlink': [self._symlinks[rel_path]]\\n }\\n\\n # Track hardlinks.\\n if st.st_ino in seen_inodes:\\n self._hardlinks[rel_path] = seen_inodes[st.st_ino]\\n continue\\n seen_inodes[st.st_ino] = rel_path\",\n \"def get_tree_size(thread, root, top, path, docs, sizes, inodes, depth=0, maxdepth=999):\\n global filecount\\n global skipfilecount\\n global inodecount\\n global dircount\\n global skipdircount\\n global total_doc_count\\n global warnings\\n\\n size = 0\\n size_du = 0\\n dirs = 0\\n files = 0\\n f_count = 0\\n d_count = 0\\n f_skip_count = 0\\n d_skip_count = 0\\n tot_doc_count = 0\\n parent_path = None\\n size_norecurs = 0\\n size_du_norecurs = 0\\n files_norecurs = 0\\n dirs_norecurs = 0\\n \\n # use alt scanner\\n # try to get stat info for dir path\\n if options.altscanner:\\n try:\\n d_stat = alt_scanner.stat(path)\\n except RuntimeError as e:\\n logmsg = '[{0}] ALT SCANNER ERROR: {1}'.format(thread, e)\\n logger.error(logmsg)\\n if logtofile: logger_warn.error(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n return 0, 0, 0, 0\\n except Exception as e:\\n logmsg = '[{0}] ALT SCANNER EXCEPTION: {1}'.format(thread, e)\\n logger.exception(logmsg)\\n if logtofile: logger_warn.exception(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n return 0, 0, 0, 0\\n else:\\n # try to get os stat info for dir path\\n try:\\n d_stat = os.stat(path)\\n except OSError as e:\\n logmsg = '[{0}] OS ERROR: {1}'.format(thread, e)\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n return 0, 0, 0, 0\\n \\n # restore times (atime/mtime)\\n if restore_times:\\n res, err = set_times(path, d_stat.st_atime, d_stat.st_mtime)\\n if not res:\\n logmsg = 'OS ERROR setting file times for {0} (error {1})'.format(path, err)\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n\\n # scan directory\\n try:\\n logger.debug('[{0}] Scanning path {1}...'.format(thread, path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] Scanning path {1}...'.format(thread, path))\\n for entry in os.scandir(path):\\n logger.debug('[{0}] Scanning dir entry {1}...'.format(thread, entry.path))\\n if options.vverbose:\\n logger.info('[{0}] Scanning dir entry {1}...'.format(thread, entry.path)) \\n \\n if entry.is_symlink():\\n logger.debug('[{0}] skipping symlink {1}'.format(thread, entry.path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] skipping symlink {1}'.format(thread, entry.path))\\n pass\\n elif entry.is_dir():\\n d_count += 1\\n if not dir_excluded(entry.path):\\n dirs += 1\\n dirs_norecurs += 1\\n if maxdepth > 0:\\n if depth < maxdepth:\\n # recurse into subdir\\n if not quit:\\n s, sdu, fc, dc = get_tree_size(thread, root, top, entry.path, docs, sizes, inodes, depth+1, maxdepth)\\n size += s\\n size_du += sdu\\n files += fc\\n dirs += dc\\n else:\\n logger.debug('[{0}] not descending {1}, maxdepth {2} reached'.format(\\n thread, entry.path, maxdepth))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] not descending {1}, maxdepth {2} reached'.format(\\n thread, entry.path, maxdepth))\\n else:\\n logger.debug('[{0}] skipping dir {1}'.format(thread, entry.path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] skipping dir {1}'.format(thread, entry.path))\\n d_skip_count += 1\\n else:\\n f_count += 1\\n if not file_excluded(entry.name):\\n f_stat = entry.stat()\\n # restore times (atime/mtime)\\n if restore_times and not options.altscanner:\\n ret = set_times(entry.path, f_stat.st_atime, f_stat.st_mtime)\\n if not ret:\\n with crawl_thread_lock:\\n warnings += 1\\n\\n fsize = f_stat.st_size\\n # calculate allocated file size (du size)\\n if IS_WIN:\\n fsize_du = fsize\\n elif options.altscanner:\\n fsize_du = f_stat.st_sizedu\\n else:\\n fsize_du = f_stat.st_blocks * blocksize\\n # set fsize_du to 0 if inode in inodes list (hardlink)\\n if f_stat.st_ino in inodes:\\n fsize_du = 0\\n # add inode to inodes list if hardlink count > 1\\n elif f_stat.st_nlink > 1:\\n with crawl_thread_lock:\\n inodes.append(f_stat.st_ino)\\n fmtime_sec = time.time() - f_stat.st_mtime\\n fctime_sec = time.time() - f_stat.st_ctime\\n fatime_sec = time.time() - f_stat.st_atime\\n\\n if not exc_empty_files or (exc_empty_files and fsize > 0):\\n if fsize >= minfilesize and \\\\\\n fmtime_sec > minmtime and \\\\\\n fmtime_sec < maxmtime and \\\\\\n fctime_sec > minctime and \\\\\\n fctime_sec < maxctime and \\\\\\n fatime_sec > minatime and \\\\\\n fatime_sec < maxatime:\\n size += fsize\\n size_norecurs += fsize\\n size_du += fsize_du\\n size_du_norecurs += fsize_du\\n files += 1\\n files_norecurs += 1\\n # get owner and group names\\n if IS_WIN:\\n # for windows just set both owner and group to 0, this is what scandir returns for Windows\\n # and there is no known fast way to get Windows file owner (pywin32 is slow)\\n owner = f_stat.st_uid\\n group = f_stat.st_gid\\n else:\\n owner, group = get_owner_group_names(f_stat.st_uid, f_stat.st_gid)\\n \\n # check for bad Unicode utf-8 characters\\n try:\\n if parent_path is None:\\n parent_path = get_parent_path(entry.path)\\n file_name = get_file_name(entry.name)\\n except UnicodeError:\\n if parent_path is None:\\n parent_path = get_parent_path(entry.path, ignore_errors=True)\\n file_name = get_file_name(entry.name, ignore_errors=True)\\n logmsg = '[{0}] UNICODE WARNING {1}'.format(thread, os.path.join(parent_path, file_name))\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n \\n # index doc dict\\n data = {\\n 'name': file_name,\\n 'extension': os.path.splitext(entry.name)[1][1:].lower(),\\n 'parent_path': parent_path,\\n 'size': fsize,\\n 'size_du': fsize_du,\\n 'owner': owner,\\n 'group': group,\\n 'mtime': datetime.utcfromtimestamp(int(f_stat.st_mtime)).isoformat(),\\n 'atime': datetime.utcfromtimestamp(int(f_stat.st_atime)).isoformat(),\\n 'ctime': datetime.utcfromtimestamp(int(f_stat.st_ctime)).isoformat(),\\n 'nlink': f_stat.st_nlink,\\n 'ino': str(f_stat.st_ino),\\n 'type': 'file'\\n }\\n\\n # check if using altscanner and if any additional meta data to add to data dict\\n if options.altscanner:\\n try:\\n extrameta_dict = alt_scanner.add_meta(entry.path, f_stat)\\n if extrameta_dict is not None:\\n data.update(extrameta_dict)\\n except Exception as e:\\n logmsg = '[{0}] ALT SCANNER EXCEPTION {1}'.format(thread, e)\\n logger.exception(logmsg)\\n if logtofile: logger_warn.exception(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n # check plugins for adding extra meta data to data dict\\n if plugins_enabled and plugins_files:\\n for plugin in plugins:\\n try:\\n # check if plugin is for file doc\\n if plugin.for_type('file'):\\n extrameta_dict = plugin.add_meta(entry.path, f_stat)\\n if extrameta_dict is not None:\\n data.update(extrameta_dict)\\n except (RuntimeWarning, RuntimeError) as e:\\n err_message = e.args[0]\\n if e.__class__ == RuntimeWarning:\\n logmsg = '[{0}] PLUGIN WARNING: {1}'.format(thread, err_message)\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n else:\\n logmsg = '[{0}] PLUGIN ERROR: {1}'.format(thread, err_message)\\n logger.error(logmsg)\\n if logtofile: logger_warn.error(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n extrameta_dict = e.args[1]\\n if extrameta_dict is not None:\\n data.update(extrameta_dict)\\n except Exception as e:\\n logmsg = '[{0}] PLUGIN EXCEPTION {1}'.format(thread, e)\\n logger.exception(logmsg)\\n if logtofile: logger_warn.exception(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n # add file doc to docs list and upload to ES once it reaches certain size\\n docs.append(data.copy())\\n doc_count = len(docs)\\n if doc_count >= es_chunksize:\\n start_bulk_upload(thread, root, docs)\\n tot_doc_count += doc_count\\n docs.clear()\\n\\n else:\\n f_skip_count += 1\\n logger.debug('[{0}] skipping file {1}'.format(thread, entry.path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] skipping file {1}'.format(thread, entry.path))\\n else:\\n f_skip_count += 1\\n logger.debug('[{0}] skipping file {1}'.format(thread, entry.path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] skipping file {1}'.format(thread, entry.path))\\n else:\\n f_skip_count += 1\\n logger.debug('[{0}] skipping file {1}'.format(thread, entry.path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] skipping file {1}'.format(thread, entry.path))\\n \\n # if not excluding empty dirs is set or exclude empty dirs is set but there are files or \\n # dirs in the current directory, index the dir\\n if not exc_empty_dirs or (exc_empty_dirs and (files > 0 or dirs > 0)):\\n # get owner and group names\\n if IS_WIN:\\n # for windows just set both owner and group to 0, this is what scandir returns for Windows\\n # and there is no known fast way to get Windows file owner (pywin32 is slow)\\n owner = d_stat.st_uid\\n group = d_stat.st_gid\\n else:\\n owner, group = get_owner_group_names(d_stat.st_uid, d_stat.st_gid)\\n \\n # check for bad Unicode utf-8 characters\\n try:\\n file_name = get_dir_name(path)\\n parent_path = get_parent_path(path)\\n except UnicodeError:\\n file_name = get_dir_name(path, ignore_errors=True)\\n parent_path = get_parent_path(path, ignore_errors=True)\\n logmsg = '[{0}] UNICODE WARNING {1}'.format(thread, os.path.join(parent_path, file_name))\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n \\n # index doc dict\\n data = {\\n 'name': file_name,\\n 'parent_path': parent_path,\\n 'size': size,\\n 'size_norecurs': size_norecurs,\\n 'size_du': size_du,\\n 'size_du_norecurs': size_du_norecurs,\\n 'file_count': files,\\n 'file_count_norecurs': files_norecurs, \\n 'dir_count': dirs + 1,\\n 'dir_count_norecurs': dirs_norecurs + 1,\\n 'dir_depth': depth,\\n 'mtime': datetime.utcfromtimestamp(int(d_stat.st_mtime)).isoformat(),\\n 'atime': datetime.utcfromtimestamp(int(d_stat.st_atime)).isoformat(),\\n 'ctime': datetime.utcfromtimestamp(int(d_stat.st_ctime)).isoformat(),\\n 'nlink': d_stat.st_nlink,\\n 'ino': str(d_stat.st_ino),\\n 'owner': owner,\\n 'group': group,\\n 'type': 'directory'\\n }\\n\\n # check if using altscanner and if any additional meta data to add to data dict\\n if options.altscanner:\\n try:\\n extrameta_dict = alt_scanner.add_meta(path, d_stat)\\n if extrameta_dict is not None:\\n data.update(extrameta_dict)\\n except Exception as e:\\n logmsg = '[{0}] ALT SCANNER EXCEPTION {1}'.format(thread, e)\\n logger.exception(logmsg)\\n if logtofile: logger_warn.exception(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n # check plugins for adding extra meta data to data dict\\n if plugins_enabled and plugins_dirs:\\n for plugin in plugins:\\n # check if plugin is for directory doc\\n try:\\n if plugin.for_type('directory'):\\n extrameta_dict = plugin.add_meta(path, d_stat)\\n if extrameta_dict is not None:\\n data.update(extrameta_dict)\\n except (RuntimeWarning, RuntimeError) as e:\\n err_message = e.args[0]\\n if e.__class__ == RuntimeWarning:\\n logmsg = '[{0}] PLUGIN WARNING: {1}'.format(thread, err_message)\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n else:\\n logmsg = '[{0}] PLUGIN ERROR: {1}'.format(thread, err_message)\\n logger.error(logmsg)\\n if logtofile: logger_warn.error(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n extrameta_dict = e.args[1]\\n if extrameta_dict is not None:\\n data.update(extrameta_dict)\\n except Exception as e:\\n logmsg = '[{0}] PLUGIN EXCEPTION: {1}'.format(thread, e)\\n logger.exception(logmsg)\\n if logtofile: logger_warn.exception(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n \\n if depth > 0:\\n # add file doc to docs list and upload to ES once it reaches certain size\\n docs.append(data.copy())\\n doc_count = len(docs)\\n if doc_count >= es_chunksize:\\n start_bulk_upload(thread, root, docs)\\n tot_doc_count += doc_count\\n docs.clear()\\n \\n else:\\n with crawl_thread_lock:\\n sizes[root] = data.copy()\\n else:\\n d_skip_count += 1\\n logger.debug('[{0}] skipping empty dir {1}'.format(thread, path))\\n if options.verbose or options.vverbose:\\n logger.info('[{0}] skipping empty dir {1}'.format(thread, path))\\n if dirs > 0: dirs -= 1\\n\\n with crawl_thread_lock:\\n dircount[root] += d_count - d_skip_count\\n filecount[root] += f_count - f_skip_count\\n skipfilecount[root] += f_skip_count\\n skipdircount[root] += d_skip_count\\n total_doc_count[root] += tot_doc_count\\n inodecount[root] += d_count + f_count \\n\\n except OSError as e:\\n logmsg = '[{0}] OS ERROR: {1}'.format(thread, e)\\n logger.warning(logmsg)\\n if logtofile: logger_warn.warning(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n except RuntimeError as e:\\n logmsg = '[{0}] ALT SCANNER ERROR: {1}'.format(thread, e)\\n logger.error(logmsg)\\n if logtofile: logger_warn.error(logmsg)\\n with crawl_thread_lock:\\n warnings += 1\\n pass\\n \\n return size, size_du, files, dirs\",\n \"def _walk_dir(self, rootpath):\\n assert os.path.isabs(rootpath)\\n assert rootpath not in self._dirs\\n relpath = self._get_rel_path(rootpath)\\n self._dirs[relpath] = Directory(rootpath, relpath, None)\\n for dirpath, dirnames, filenames in os.walk(rootpath):\\n if 'refdata' in dirnames:\\n dirnames.remove('refdata')\\n currentdir = self._dirs[self._get_rel_path(dirpath)]\\n # Loop through a copy so that we can modify dirnames.\\n for dirname in list(dirnames):\\n fullpath = os.path.join(dirpath, dirname)\\n if fullpath == self._build_root:\\n dirnames.remove(dirname)\\n continue\\n relpath = self._get_rel_path(fullpath)\\n self._dirs[relpath] = Directory(fullpath, relpath, currentdir)\\n extensions = ('.h', '.cuh', '.hpp', '.c', '.cc', '.cpp', '.cu', '.bm')\\n for filename in filenames:\\n basename, extension = os.path.splitext(filename)\\n if extension in extensions:\\n fullpath = os.path.join(dirpath, filename)\\n relpath = self._get_rel_path(fullpath)\\n self._files[relpath] = File(fullpath, relpath, currentdir)\\n elif extension == '.cmakein':\\n extension = os.path.splitext(basename)[1]\\n if extension in extensions:\\n fullpath = os.path.join(dirpath, filename)\\n relpath = self._get_rel_path(fullpath)\\n sourcefile = GeneratorSourceFile(fullpath, relpath, currentdir)\\n self._files[relpath] = sourcefile\\n fullpath = os.path.join(dirpath, basename)\\n relpath = self._get_rel_path(fullpath)\\n fullpath = os.path.join(self._build_root, relpath)\\n generatedfile = GeneratedFile(fullpath, relpath, currentdir)\\n self._files[relpath] = generatedfile\\n generatedfile.set_generator_source(sourcefile)\\n elif extension in ('.l', '.y', '.pre'):\\n fullpath = os.path.join(dirpath, filename)\\n relpath = self._get_rel_path(fullpath)\\n self._files[relpath] = GeneratorSourceFile(fullpath, relpath, currentdir)\",\n \"def GenerateHierarchies(self,id_range):\\n classed = []\\n file_list = self.GetFileList(id_range)\\n if file_list:\\n for fl in file_list:\\n cls = self.GetClassesFromFile(fl)\\n if cls:\\n for c in cls:\\n self.classes.append(c)\\n\\n for c in self.classes:\\n if not self.Inherits(c):\\n self.base_cls.append(c)\\n self.classes.remove(c)\\n\\n for c in self.base_cls:\\n kids = self.FindChilds(c)\\n if c not in classed:\\n root = self.AppendItem(self.root,self.CleanName(c))\\n classed.append(c)\\n if kids:\\n for n in kids:\\n root2 = self.AppendItem(root,self.CleanName(n))\\n kids_kids = self.FindChilds(n)\\n i = 0\\n if kids_kids:\\n kids_len = len(kids_kids)\\n while kids_kids:\\n try:\\n kid = kids_kids[i]\\n except: pass\\n has_kid = self.FindChilds(kid)\\n if not has_kid and i == kids_len: break\\n i+=1\\n root3 = self.AppendItem(root2,self.CleanName(kid))\\n\\n\\n self.classes = []\",\n \"def ND_params_tree(args):\\n start = time.time()\\n # We have some files recorded before there were flats, so get ready to\\n # loop back for them\\n skipped_dirs = []\\n \\n # list date directory one level deep\\n totalcount = 0\\n totaltorus = 0\\n totalNa = 0\\n totaltime = 0\\n dirs = [os.path.join(args.directory, d)\\n for d in os.listdir(args.directory) if os.path.isdir(os.path.join(args.directory, d))]\\n persistent_default_ND_params = None\\n for d in sorted(dirs):\\n D.say(d)\\n try:\\n default_ND_params = get_default_ND_params(d)\\n persistent_default_ND_params = default_ND_params\\n except KeyboardInterrupt:\\n # Allow C-C to interrupt\\n raise\\n except Exception as e:\\n log.warning('Problem with flats: ' + str(e))\\n if persistent_default_ND_params is None:\\n log.error('No flats have been processed yet! Skipping directory')\\n continue\\n log.warning('Using previous value for default_ND_params')\\n default_ND_params = persistent_default_ND_params\\n \\n (count, torus_count, Na_count, elapsed, T_per_file) \\\\\\n = ND_params_dir(d, default_ND_params=default_ND_params)\\n print(count, torus_count, Na_count, elapsed)\\n totalcount += count\\n totaltorus += torus_count\\n totalNa += Na_count\\n totaltime += elapsed\\n end = time.time()\\n D.say('Total elapsed time: ' + str(end - start) + 's')\\n D.say(str(totalcount) + ' obj files took ' + str(totaltime) + 's')\\n D.say('Average time per file: ' + str(totalcount / totaltime) + 's')\\n D.say('Total torus: ' + str(totaltorus))\\n D.say('Total Na: ' + str(totalNa))\",\n \"def generate_output(input_filename: str, output_filename: str, goal_node: Node,\\n generated: set) -> None:\\n\\n input_stream = io.open(input_filename, 'r', encoding='utf-8', errors='ignore',\\n newline='\\\\n')\\n with open(output_filename, 'w') as out_file:\\n for i in range(0, 10):\\n out_file.write(input_stream.readline().rstrip())\\n out_file.write('\\\\n')\\n \\\"\\\"\\\" The first ten lines of the output file are identical to those in the \\n input file. The tenth line should be skipped because it's blank.\\\"\\\"\\\"\\n out_file.write(str(goal_node.path_cost) + '\\\\n')\\n # Line 11 of the output, the depth level d\\n out_file.write(str(len(generated)) + '\\\\n')\\n # Line 12 of the output, the total number of nodes generated\\n\\n # Writing Line 13 of the output, the sequence of moves\\n length = len(goal_node.path_history)\\n for i in range(length - 1):\\n out_file.write(goal_node.path_history[i] + ' ')\\n out_file.write(goal_node.path_history[length - 1] + '\\\\n')\\n\\n # Writing Line 14 of the output, the f(n) values\\n f_line = str(goal_node.f) + ' '\\n parent = goal_node.parent\\n while parent: # Loop stops when parent == None\\n f_line += (str(parent.f) + ' ')\\n parent = parent.parent\\n f_list = f_line.split(' ')\\n # Breaks down the string to the integers it contains\\n reverse = ''\\n for i in range(len(f_list) - 2, -1, -1):\\n # f_line[len(f_line)-1] is an extra whitespace character and\\n # thus shouldn't be copied\\n reverse += str(f_list[i])\\n if i != 0:\\n reverse += ' '\\n \\\"\\\"\\\" The order of the f(n) values in f_line is from goal node \\n to root node. The four lines above reverse the order, which \\n is what the output format expects.\\\"\\\"\\\"\\n out_file.write(reverse)\\n\\n out_file.close()\",\n \"def recursive():\\n with Local() as tun:\\n tun.call(recursive)\",\n \"def get(self):\\n for path, dirs, files in os.walk(self.directory):\\n folders = path[self.start:].split(os.sep)\\n if self.branches:\\n if self._filter(folders, 'folders'):\\n files = dict.fromkeys(files)\\n parent = reduce(dict.get, folders[:-1], self.tree_dict)\\n parent[folders[-1]] = files\\n else:\\n files = dict.fromkeys(files)\\n parent = reduce(dict.get, folders[:-1], self.tree_dict)\\n parent[folders[-1]] = files\\n return self.tree_dict\",\n \"def build_auxiliary_structures(nodes_filename, ways_filename):\\n nodes = {}\\n for way in read_osm_data(ways_filename):\\n highway_type = way['tags'].get('highway', '( ͡° ͜ʖ ͡°)')\\n if highway_type in ALLOWED_HIGHWAY_TYPES:\\n nodes_along_way = way['nodes'] # List of nodes along this way\\n for i in range(len(nodes_along_way) - 1):\\n # A pair of adjacent nodes along this way\\n left = nodes_along_way[i]\\n right = nodes_along_way[i + 1]\\n default_speed_limit = DEFAULT_SPEED_LIMIT_MPH[highway_type]\\n # If this way doesn't have a speed limit tag, we use the default value based on highway type\\n speed_limit = way['tags'].get('maxspeed_mph', default_speed_limit)\\n\\n def build_data(root, adjacent):\\n \\\"\\\"\\\"\\n root: ID of some node along way\\n adjacent: ID of some node adjacent to root node along way\\n \\\"\\\"\\\"\\n new_node_data_struct = {'adjacent': {adjacent: speed_limit}} # Init dict for node data structure\\n root_data = nodes.get(root, new_node_data_struct)\\n # There might be another way where root and adjacent are directly adjacent, so our\\n # speed limit is the max of the speed limits of those two ways:\\n root_data['adjacent'][adjacent] = max(root_data['adjacent'].get(adjacent, 0), speed_limit)\\n nodes[root] = root_data # Add the data on root to our dictionary of node data\\n\\n build_data(left, right)\\n if not way['tags'].get('oneway', '( ͡° ͜ʖ ͡°)') == 'yes':\\n # If this isn't a oneway way, we can build the data structure for the next node as well\\n build_data(right, left)\\n elif right == nodes_along_way[-1]:\\n # In non-oneway ways, the above build_data(right, left) call creates the data structure\\n # for the final node at the same time as the penultimate one. However, in the case of a\\n # oneway path, we have to do it manually:\\n nodes[right] = nodes.get(right, {'adjacent': {}})\\n\\n for node in read_osm_data(nodes_filename):\\n id = node['id']\\n if id in nodes:\\n # If the id of this node in the generator was on a valid way, we add the data about that node\\n # to its dictionary in nodes.\\n # Add lat/lon data\\n nodes[id]['lat'] = node['lat']\\n nodes[id]['lon'] = node['lon']\\n\\n return nodes\",\n \"def ind_repl(self, dirkey, filekey, txtkey):\\n for dir in self.dirs:\\n for file in self.get_files(dir):\\n self.repl_file(dir, file, dirkey, filekey, txtkey)\",\n \"def getHierarchy(unique_name):\",\n \"def getHierarchy(unique_name):\",\n \"def getHierarchy(unique_name):\",\n \"def ref_mapping_directory(tmpdir_factory):\\n basedir = tmpdir_factory.mktemp('data')\\n mapdir = basedir.mkdir('mappings')\\n\\n template = textwrap.dedent(\\\"\\\"\\\"\\n [ molecule ]\\n dummy_{0}\\n\\n [ from ]\\n {1}\\n\\n [ to ]\\n {2}\\n\\n [ atoms ]\\n 0 X1{0} A{0} B{0}\\n 1 X2{0} C{0} D{0}\\n \\\"\\\"\\\")\\n\\n mappings = collections.defaultdict(lambda: collections.defaultdict(dict))\\n\\n force_fields_from = ['ff{}'.format(i) for i in range(4)]\\n force_fields_to = force_fields_from + ['only_to']\\n force_fields_from = force_fields_from + ['only_from']\\n iterate_on = itertools.product(force_fields_from, force_fields_to, range(3))\\n for idx, (from_ff, to_ff, _) in enumerate(iterate_on):\\n mapfile = mapdir / 'file{}.map'.format(idx)\\n with open(str(mapfile), 'w') as outfile:\\n outfile.write(template.format(idx, from_ff, to_ff))\\n\\n mapping = {\\n (0, 'X1{}'.format(idx)): [(0, 'A{}'.format(idx)), (0, 'B{}'.format(idx))],\\n (0, 'X2{}'.format(idx)): [(0, 'C{}'.format(idx)), (0, 'D{}'.format(idx))],\\n }\\n weights = {\\n (0, 'A{}'.format(idx)): {(0, 'X1{}'.format(idx)): 0.5},\\n (0, 'B{}'.format(idx)): {(0, 'X1{}'.format(idx)): 0.5},\\n (0, 'C{}'.format(idx)): {(0, 'X2{}'.format(idx)): 0.5},\\n (0, 'D{}'.format(idx)): {(0, 'X2{}'.format(idx)): 0.5},\\n }\\n extra = []\\n mappings[from_ff][to_ff]['dummy_{}'.format(idx)] = (mapping, weights, extra)\\n\\n mappings = {from_ff: dict(to_ff) for from_ff, to_ff in mappings.items()}\\n\\n return Path(str(basedir)), mappings\",\n \"def content(tmp_loc, ref_names_dict, order):\\n \\n fl = '[Content_Types].xml'\\n inp_path = '/'.join([tmp_loc, fl])\\n out_path = '/'.join([output_path, fl])\\n \\n cnt_lst = []\\n asset_lst = []\\n def_att = []\\n d = dict()\\n \\n root1,tree1 = gen_tree(inp_path)\\n root2,tree2 = gen_tree(out_path)\\n \\n # get all the extensions belongs to \\\"Default\\\" tag\\n for relation in root2:\\n if 'Default' in relation.tag:\\n def_att.append(relation.attrib['Extension'])\\n else:\\n break\\n \\n for relation in root1:\\n if 'Override' in relation.tag:\\n attrib = relation.attrib['PartName'][1:]\\n try:\\n cnt = attrib.split('ppt/')[-1]\\n ini = '/ppt/'\\n except:\\n cnt = attrib\\n ini = '/'\\n if cnt in ref_names_dict.keys():\\n relation.attrib['PartName'] = f'{ini}{ref_names_dict[cnt]}'\\n cnt_lst.append(relation)\\n # asset_lst.append(relation.attrib['PartName'])\\n else:\\n cnt_lst.append(relation)\\n if relation.attrib['PartName'] not in asset_lst:\\n asset_lst.append(relation.attrib['PartName'])\\n else:\\n attrib = relation.attrib['Extension']\\n if attrib not in def_att:\\n cnt_lst.append(relation)\\n # asset_lst.append(relation.attrib['Extension'])\\n # deal with the assest_lst\\n # print(\\\"AA: \\\", asset_lst)\\n cnt_lst = natsort.natsorted(cnt_lst)\\n for ele in cnt_lst:\\n prev = tree2.find(ele.tag)\\n prev.addnext(ele)\\n \\n tree2.write(out_path, pretty_print=True, xml_declaration=True, encoding='UTF-8', standalone=True)\\n \\n unq_attr = []\\n for relation in root2:\\n if 'Override' in relation.tag:\\n if relation.attrib['PartName'] not in unq_attr:\\n unq_attr.append(relation.attrib['PartName'])\\n else:\\n root2.remove(relation)\\n tree2.write(out_path, pretty_print=True, xml_declaration=True, encoding='UTF-8', standalone=True)\",\n \"def processFallbackStageOut():\\n\\n while True:\\n report, node = (yield)\\n localReport = {}\\n for subnode in node.children:\\n if subnode.name in ['phedex-node', 'command', 'option', 'lfn-prefix']:\\n localReport[subnode.name] = subnode.attrs.get('value', None)\\n report['fallbackStageOut'] = [localReport]\",\n \"def touched_files(self, parent):\",\n \"def _analyze(self):\\n for _, self.subdirs, files in os.walk(self.path):\\n if self.p.sort:\\n self.subdirs.sort()\\n files.sort()\\n for f in files:\\n self._analyze_file(fileextlow(f), f)\\n break # stop walk() from entering subdirectories\\n\\n self.p.nr_dirs += 1\\n if self.lossless or self.compressed or self.videos:\\n if self.lossless or self.compressed:\\n if not self.images:\\n if self.p.warn_covers:\\n print(f\\\"{W}{self.path}{R}: no cover file\\\")\\n self.p.nr_no_cover += 1\\n elif not have_valid_cover_name(self.images):\\n if self.p.warn_covers:\\n print(f\\\"{W}{self.path}{R}: wrong cover names\\\")\\n self.p.nr_wrong_cover_name += 1\\n if self.lossless:\\n if self.compressed:\\n self.p.nr_mixed_lossless_compressed += 1\\n else:\\n self.p.nr_lossless_dirs += 1\\n\\n if self.cue:\\n if not self.lossless:\\n if self.p.warn_cue:\\n print(f\\\"{W}{self.path}{R}: cue but no lossless files\\\")\\n self.p.nr_lossy_cue += 1\\n elif not self.compressed:\\n if len(self.cue) == 1:\\n self.p.nr_cue += 1\\n else:\\n if self.p.warn_cue:\\n print(f\\\"{W}{self.path}{R}: {len(self.cue)} cue files\\\")\\n self.p.nr_multiple_cue += 1\\n\\n self.p.nr_media_dirs += 1\\n self.p.nr_lossless += len(self.lossless)\\n self.p.nr_compressed += len(self.compressed)\\n self.p.nr_video_files += len(self.videos)\\n self.p.nr_ignored += self.ignored\\n self.p.unknown.update(self.unknown)\\n else:\\n if self.images and not self.subdirs:\\n self.p.nr_only_images += 1\\n else:\\n self.p.nr_no_media_dirs += 1\",\n \"def set_depth(node, depth):\\n setattr(node[0], \\\"depth\\\", depth)\",\n \"def showFileTree():\\n\\treturn 0\",\n \"def __genAttributesROOT( self, file, indent = ' ' ):\\r\\n # Go through all actively tracked ASG's (formalisms)\\r\\n for modelMetaName in self.__trackASG.keys():\\r\\n if( not self.__isASGbyNameEmpty( modelMetaName ) ):\\r\\n # This formalism has at least one entity, we NEED IT\\r\\n ASG = self.getASGbyName( modelMetaName )\\r\\n \\r\\n #todo: clean this up\\r\\n try:\\r\\n modelTracker = self.__trackAttributes[ modelMetaName ]\\r\\n except:\\r\\n print 'ERROR: see ASG.py in __genAttributesROOT(), caused by Buttons Model pointing to a Formalism with a different name'\\r\\n print 'modelMetaName', modelMetaName \\r\\n print 'self.__trackAttributes', self.__trackAttributes\\r\\n print 'self.__trackASG', self.__trackASG\\r\\n \\r\\n file.write( '\\\\n'+indent+'# --- Generating attributes code for ASG '\\r\\n +modelMetaName+' ---\\\\n' ) \\r\\n # DOH! Some formalisms may not have any attributes at all!\\r\\n if( len( modelTracker ) > 0 ):\\r\\n file.write( indent + 'if( ' + modelMetaName + 'RootNode ): ' )\\r\\n i2 = indent + ' '\\r\\n \\r\\n #Generates code for the attributes value\\r\\n for attr in modelTracker.keys():\\r\\n #print attr, ASG.getAttrValue(attr)\\r\\n file.write( '\\\\n'+i2+'# '+attr+'\\\\n' )\\r\\n \\r\\n # Write its value to file\\r\\n ASG.getAttrValue(attr).writeValue2File ( file = file, indent=i2, \\r\\n objName = modelMetaName+'RootNode.'+attr, depth = 1,\\r\\n generatingCode = 0) \\r\\n else: \\r\\n file.write( indent+'# No attributes to generate!\\\\n' )\\r\\n file.write( indent+'# --- ASG attributes over ---\\\\n\\\\n' )\",\n \"def _save_tree_pickle(self, folderpath):\\n\\n if not os.path.exists(folderpath):\\n raise EnvironmentError('Unable to save pickle file to {}, does not exist'.format(folderpath))\\n self.tree.manager = None\\n\\n picklefile = open(os.path.join(folderpath, \\\"grid.pickle\\\"), \\\"wb\\\")\\n data = {}\\n for ky, val in self.__dict__.items():\\n if ky not in ['data', 'node_data']:\\n data[ky] = val\\n pickle.dump(data, picklefile, -1)\",\n \"def improve_tree(tree, freq_dict):\\n # todo\",\n \"def _fix_other_tree(self, this_tree, other_tree):\\n parent_dir, name = osutils.split(self._target_subdir)\\n parent_id = this_tree.path2id(parent_dir)\\n\\n root_ie = other_tree.inventory.root\\n root_ie.parent_id = parent_id\\n root_ie.name = name\\n\\n new_file_id = generate_ids.gen_file_id(name)\\n trace.mutter('munging root_ie.file_id: %s => %s', root_ie.file_id,\\n new_file_id)\\n del other_tree.inventory._byid[root_ie.file_id]\\n root_ie.file_id = new_file_id\\n other_tree.inventory._byid[new_file_id] = root_ie\\n # We need to fake a new id for root_ie\\n for child_ie in root_ie.children.itervalues():\\n child_ie.parent_id = new_file_id\",\n \"def generate(pref_file, random, out_file=\\\"tree.obj\\\"):\\n global writer\\n writer = ObjWriter(out_file)\\n global config\\n config = configparser.RawConfigParser()\\n global random_en\\n random_en = random\\n config.read(pref_file)\\n _draw_tree(0, config.getfloat(\\\"params\\\", \\\"radius\\\"), config.getfloat(\\\"params\\\", \\\"length\\\"), deque([]))\\n writer.write_all()\\n writer.close()\",\n \"def initialize_parents(self, filename=None):\\n\\t\\tpass\",\n \"def first_found_merging(file_names, tree_name):\\n\\n tree_branches = {}\\n for ifile, file_name in enumerate(file_names):\\n file_ = uproot.open(file_name)\\n if tree_name+\\\";1\\\" in file_.keys():\\n tree = file_[tree_name].arrays()\\n tree_branches = { k: tree[k] for k in tree.fields }\\n break\\n\\n return tree_branches\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67543304","0.5652397","0.55918777","0.5476559","0.5439046","0.54237384","0.53918606","0.538221","0.5363778","0.5344074","0.52756155","0.521393","0.517851","0.51598054","0.5157991","0.5055687","0.5039144","0.50361437","0.5031006","0.49998572","0.49961793","0.4990759","0.4990528","0.49789137","0.49784577","0.4962","0.4921389","0.49130318","0.4912926","0.49101174","0.49098918","0.48984993","0.4878097","0.48742282","0.4853764","0.48457587","0.48447552","0.48345372","0.4834411","0.48306257","0.48238802","0.4821721","0.48191148","0.48126283","0.480706","0.4806084","0.48025307","0.47991967","0.47986546","0.47986546","0.47900113","0.47822934","0.47814542","0.47752744","0.47731203","0.47596648","0.47596562","0.47585803","0.47494155","0.47490996","0.4741063","0.47399274","0.4735111","0.4734106","0.47289732","0.47267666","0.47242358","0.4720721","0.47133848","0.4704783","0.4700066","0.4689964","0.4689929","0.46848536","0.46774375","0.46680853","0.46645838","0.46633646","0.46599823","0.46588853","0.46539325","0.46456167","0.46413532","0.46340698","0.46340698","0.46340698","0.46322963","0.46311188","0.46308228","0.46297547","0.46236202","0.46178994","0.46164414","0.4611574","0.46115148","0.46104842","0.46090937","0.46068272","0.4602598","0.46021563"],"string":"[\n \"0.67543304\",\n \"0.5652397\",\n \"0.55918777\",\n \"0.5476559\",\n \"0.5439046\",\n \"0.54237384\",\n \"0.53918606\",\n \"0.538221\",\n \"0.5363778\",\n \"0.5344074\",\n \"0.52756155\",\n \"0.521393\",\n \"0.517851\",\n \"0.51598054\",\n \"0.5157991\",\n \"0.5055687\",\n \"0.5039144\",\n \"0.50361437\",\n \"0.5031006\",\n \"0.49998572\",\n \"0.49961793\",\n \"0.4990759\",\n \"0.4990528\",\n \"0.49789137\",\n \"0.49784577\",\n \"0.4962\",\n \"0.4921389\",\n \"0.49130318\",\n \"0.4912926\",\n \"0.49101174\",\n \"0.49098918\",\n \"0.48984993\",\n \"0.4878097\",\n \"0.48742282\",\n \"0.4853764\",\n \"0.48457587\",\n \"0.48447552\",\n \"0.48345372\",\n \"0.4834411\",\n \"0.48306257\",\n \"0.48238802\",\n \"0.4821721\",\n \"0.48191148\",\n \"0.48126283\",\n \"0.480706\",\n \"0.4806084\",\n \"0.48025307\",\n \"0.47991967\",\n \"0.47986546\",\n \"0.47986546\",\n \"0.47900113\",\n \"0.47822934\",\n \"0.47814542\",\n \"0.47752744\",\n \"0.47731203\",\n \"0.47596648\",\n \"0.47596562\",\n \"0.47585803\",\n \"0.47494155\",\n \"0.47490996\",\n \"0.4741063\",\n \"0.47399274\",\n \"0.4735111\",\n \"0.4734106\",\n \"0.47289732\",\n \"0.47267666\",\n \"0.47242358\",\n \"0.4720721\",\n \"0.47133848\",\n \"0.4704783\",\n \"0.4700066\",\n \"0.4689964\",\n \"0.4689929\",\n \"0.46848536\",\n \"0.46774375\",\n \"0.46680853\",\n \"0.46645838\",\n \"0.46633646\",\n \"0.46599823\",\n \"0.46588853\",\n \"0.46539325\",\n \"0.46456167\",\n \"0.46413532\",\n \"0.46340698\",\n \"0.46340698\",\n \"0.46340698\",\n \"0.46322963\",\n \"0.46311188\",\n \"0.46308228\",\n \"0.46297547\",\n \"0.46236202\",\n \"0.46178994\",\n \"0.46164414\",\n \"0.4611574\",\n \"0.46115148\",\n \"0.46104842\",\n \"0.46090937\",\n \"0.46068272\",\n \"0.4602598\",\n \"0.46021563\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61889166"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":76296,"cells":{"query":{"kind":"string","value":"Print a simple greeting to each user in the list."},"document":{"kind":"string","value":"def greet_user(names):\n\n for name in names:\n msg = f\"Hello, {name.title()} !\"\n print(msg)"},"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 greet_users(names):\n for name in names:\n msg = \"Hello, \" + name.title() + \"!\"\n print(msg)","def greet_users(names):\n for name in names:\n msg = \"Hello, \" + name.title() + \"!\"\n print(msg)","def greet_users(names):\n for name in names:\n print(f\"Hello, {name.title()}!\")","def greeting(list_of_guests):\r\n for i in list_of_guests: \r\n print('Witaj ' + i)","def greet_users(names):\n for name in names:\n msg = f\"Hello, {name.title()}\"\n print(msg)","def greet_users(names):\n for name in names:\n msg = f\"Hello, {name.title()}!\"\n print(msg)","def greet_users(names):\n for name in names:\n msg = f\"Hello, {name.title()}!\"\n print(msg)","def print_users(self):\n for i, item in enumerate(self.users):\n print(\"{}. {}\".format(i, item.name))","def greet_user(self):\n print(\"Hello, \" + self.first_name.title() + \" \" + self.last_name.title() + \"!\")","def greet_user(self):\n print(\"Hello \" + self.first_name.title() + \" \" +\n self.last_name.title() + \", welcome back!\")","def greet_user(self):\n print(\"Welcome, \" + self.first_name.title() + \"!\")","def greet_user(self):\r\n\r\n print(\"Hello \" + self.first_name.title() + \" \" + self.last_name.title() + \".\")","def greet_user(self):\n greeting = f\"Hi {self.first_name.title()}, welcome back!\\n\"\n print(greeting)","def greet_user(self):\n print(\"\\nWelcome, \" + self.username + \"!\")","def greet_user(self):\n print(\"\\nWelcome, \" + self.username + \"!\")","def greet_user(self):\r\n\t\tprint(f\"\\nHello {self.first_name}!\\n\")","def greet_user(self):\n print(\"Hello \" + self.f_name.title() + \"!, hope you're well today!\")","def greet_user(username):\r\n print(f\"Hello, {username.title()}!\")","def greet_user(self):\n\t\tprint(f\"How are you doing {self.first_name.title()}?\")","def greet_user():\r\n print('Hi,' + FirstName + ' ' + LastName + ' thanks for joining us inside the beer app!')","async def _welcome(self, ctx, *, users: discord.User = None):\n if not users:\n await ctx.send(f\"Welcome {ctx.author.mention} to {ctx.guild.name}!\")\n else:\n if len(users) > 1:\n users = humanize_list(users)\n else:\n users = users[0].mention\n await ctx.send(f\"Welcome {users} to {ctx.guild.name}!\")","def print_users(self):\n for user in self.users.values():\n print(user)","def greet_user(self):\n print(f\"Hiya {self.username}!\")","def greet_user(username):\n print(\"Hello, \" + username.title() + \"!\")","def greet_user(username):\n print(\"Hello, \" + username.title() + \"!\")","def greet_user(username):\r\n print(\"Hello, \" + username + \"!\")","def greeter_user(username):\n print(f\"Hello {username}\")","def greet_user(username):\n print(\"Hello, \" + username + \"!\")","def greet_user(self):\n print(\"Greatings \"+ self.first_name + \" \" + self.last_name +\", welcome to the matrix.\")","def greet_user():\n print(\"Hello\")","def greeting(players_name):\n print \"\\nGreat! Welcome, \" + players_name + \". The purpose of this game is to fill in the blanks for all the sentences provided.\"","def greet_user():\n username = get_user()\n\n if username:\n print(f\"Välkommen tillbaks {username.title()}!!\")\n else:\n username = create_new_user()\n print(f\"Vi kommer ihåg dig när du återvänder {username}\")","def greet_username(username):\n print(\"Hello, \" + username.title() + \"!\")","async def greeting(self, ctx):\n await self.bot.say('hello {0.name}'.format(ctx.message.author))","def greet_user():\n print(\"Hello!\")","def greet_user():\n print(\"Hello!\")","def greet_user():\n print(\"Hello!\")","def greet(*names):\n print(names)\n for name in names:\n print(' Hello {0}!'.format(name))","def list_users(item):\n users = User.load_all_users(item)\n for user in users:\n print(user.username)","def show_greeting(self):\n self.output(' ------------------------ ')\n self.output('You are now playing ' + self.name)\n self.output(self.greeting)\n self.output(' ------------------------ ')","def welcome_user():\n welcome_string = 'Welcome to the brain Brain Games!\\n'\n print(welcome_string)\n name = prompt.string('May I have your name? ')\n print('{0}, {1}!'.format('Hello', name))","def greet_user():\r\n print(\"hello!\")","def greet_user():\n username = get_stored_username()\n if username:\n print(\"Welcome back, \" + username['Name'] + \"!\")\n else:\n username = get_new_username()\n print(\"We'll remember you when you come back, \" + username + \"!\")","def __list_all_users(self):\n\n usernames_dict = get_data.get_usernames_dict()\n if len(usernames_dict) > 0:\n first_str = 'user'\n second_str = 'posts scraped'\n descriptor = '{:<40} {}'\n print('')\n print(descriptor.format(first_str, second_str))\n print(descriptor.format(len(first_str) * '-', len(second_str) * '-'))\n for number, username in usernames_dict.items():\n space_str = ' ' if len(str(number)) > 1 else ' '\n first = '[' + space_str + str(number) + '] ' + username\n second = str(get_data.get_user_post_count(username))\n print(descriptor.format(first, second))\n else:\n print('no users found in the database')","def greeting(self):\n print(\"Hello! My name is {name}.\".format(name=self.name))","def greeting(self):\n print(\"Hello! My name is {name}.\".format(name=self.name))","def greet_user():\n username = load_user_data()\n if username != None:\n print(\"Welcome back, \" + username)\n else:\n register_user()","def greeting(name, message):\n print(f'Hello {name}!')\n print(message)","def user_list(server_object, client, address, command_args):\n\n\tmsg = \"\"\n\n\t#: Create a formatted string of all the users.\n\tfor usr in server_object.usrs.values():\n\t\tmsg += usr + '\\n'\n\n\tclient.send(msg.encode())","def list_users():\n\n users = User.query.order_by(\"last_name\").all()\n return render_template(\"users/user_list.html\", users=users)","def list_users():\n users = User.query.order_by(User.last_name, User.first_name).all()\n return render_template('index.html', users=users)","def home_list():\n\tui.lst1()\n\tui.lst2()\n\tx = db.get_users()\n\tfor i in x:\n\t\tz = len(i[1])\n\t\tf = 16-z\n\t\tl = \" \"*f\n\t\tprint i[1], l, i[4],l,i[5]\n\traw_input(\"Press [enter] to goto homescreen\")\n\thome()","def show_users():\n return 'hehe'","def greet_user(name = 'Menoetius'):\n print(\"Hello, my name is \" + name.title() + \"!\")","def welcome():\n name = prompt.string('May I have your name? ')\n print(f'Hello, {name}!') # noqa: WPS421","def greeting(name):\n print(\"\")\n print(\n \"Welcome to Mister Sweet's Mad Lib Story Telling Journey \" + name +\n \" :)\")\n print(\"\")","def show():\n return render_template(\n 'listUsers.html',\n title='List Users',\n message='These are the users in our system'\n )","def greet_user():\n\tusername = get_stored_username()\n\tif username:\n\t\tprint(\"Welcome back, \" + username + \"!\")\n\telse:\n\t\tusername = get_new_username()\n\t\tprint(\"We'll remember you when you come back, \" + username + \"!\")","def do_list_users(self, line):\n users = self.protocol.cmd_list_users(exp=line, return_list=True)\n t = PrettyTable(users[0])\n for u in users[1:]:\n t.add_row(u)\n print(t)","def greet_guest():\n print('Welcome')","def greeting():\n print('\\n',\n '=' * 45,\n \"\\n Welcome to this Module-Creation-Test-Program!!!\",\n '\\n',\n '=' * 45)","def _list_users(self):\n users = fileIO.load_json(\"users.json\")\n print(\"The list of users is as follows:\")\n for i in users:\n print(users[i][\"name\"])\n self._list_user_settings(users)","def user_list():\n\n users = User.query.all()\n\n return render_template(\"user_list.html\", users=users)","def display_list(the_list):\n print(\"\\n===================================\")\n for person in the_list:\n print(\"{name:12s}\\t\\t{phone}\".format(name=person.name, phone=person.phone))\n if the_list == []:\n print(\"\\nNo entries found!\\n\")\n print(\"===================================\\n\")","def printusers(self, irc, msg, args):\n irc.reply(self.user_report(), prefixNick=False)","def user_list():\n\n users = User.query.all()\n return render_template(\"user_list.html\", users=users)","def user_list():\n\n users = User.query.all()\n return render_template(\"user_list.html\", users=users)","def user_list():\n\n users = User.query.all()\n return render_template(\"user_list.html\", users=users)","def user_list():\n\n users = User.query.all()\n return render_template(\"user_list.html\", users=users)","def user_list():\n\n users = User.query.all()\n return render_template(\"user_list.html\", users=users)","def user_list():\n\n users = User.query.all()\n return render_template(\"user_list.html\", users=users)","def user_list_all(message=''):\n return Response(render_template('employee/user/list.html',\n users=User.query.all(),\n message=message),\n mimetype='text/html')","def user_list(ctx):\n data = ctx.obj.get_all_users()\n output_json_data(data)","def list_users(self, user=None):\n from expfactory.database.models import Participant\n\n participants = Participant.query.all()\n users = []\n for user in participants:\n users.append(self.print_user(user))\n return users","def guestlist_handler(userdata, *args):\n\t\tfor guest in userdata[\"guestlist\"]:\n\t\t\tprint(shlex.quote(guest), end=\" \")\n\t\t\n\t\tprint()","def user_list():\n\n users = User.query.all()\n \n return render_template(\"user_list.html\", users=users)","async def tod_list(self, ctx, *args):\n message = \"__Currently Playing__\\n\"\n if len(self.players) == 0:\n message = \"There are currently no users playing.\"\n for player in self.players:\n message += f\"> {str(player)[:-5]}\\n\"\n await ctx.send(message)","def do_user_list(cs, args):\n _, users = cs.users.list()\n fields = ['user_id', 'username', 'email', 'realname', 'comment']\n utils.print_list(users, fields, sortby=args.sortby)","def print_user_host(host_list, user, ul):\n \n print('\\nHost-group info pertaining to {0}:'.format(user))\n print('-'.center(80, '-'))\n if len(ul) == 0:\n print('User is not a member of any user-lists.')\n else:\n print('User belongs to the following user-lists:')\n for u in ul:\n print(u)\n print()\n print('User has access to the following host-groups:')\n for hg in host_list:\n print(hg)\n print('-'.center(80, '-') + '\\n')\n return","def user_list():\n\n users = User.query.all()\n return render_template(\"/user_list.html\", users=users)","async def list_users(self, ctx):\n \n path = \"Users\"\n headers = {\n 'accept': 'application/json'\n }\n response = send_request(method=\"get\", path=path, headers=headers)\n users = []\n for page in response:\n users.append(f\"**{page['Name']}**: ``{page['Id']}``\")\n log.debug(users)\n\n embed = embeds.make_embed(ctx=ctx, title=\"List Users\", image_url=\"https://emby.media/resources/logowhite_1881.png\")\n\n await LinePaginator.paginate([line for line in users], ctx, embed, restrict_to_user=ctx.author)","def describe_user(self):\n\t\tprint(f\"\\n{self.first_name.title()} {self.last_name.title()} \"\n\t\t\tf\"is from {self.location.title()}.\")","def greet_user():\n\tusername = get_stored_username()\n\tif username:\n\t\tprint(f\"WElcome back {username}!\")\n\telse:\n\t\tusername = get_new_username()\n\t\tprint(f\"We'll remember you when you come back again {username}! \")","def list( self, mess, args):\n user = self.get_sender_username(mess)\n args = args.replace(' ', '_')\n if user in self.users:\n user_list = 'All these users are subscribed - \\n'\n user_list += '\\n'.join(['%s :: %s' %(u, self.users[u]) for u in sorted(self.users)])\n if self.invited.keys():\n user_list += '\\n The following users are invited - \\n'\n user_list += '\\n'.join(self.invited.keys())\n self.log.info( '%s checks list of users.' % user)\n return user_list","def user_list(message=''):\n target_users = User.query.filter_by(name=request.form['name']).all()\n\n if not any(target_users):\n return search_user(\"Unknown user.\")\n\n return Response(render_template('employee/user/list.html',\n users=target_users,\n message=message),\n mimetype='text/html')","def do_list(self, arg):\n print('The roster includes the following members:\\n')\n lines = formatTable(\n map(self.memberToList, self.roster),\n [\n ColumnFormat('id', 4),\n ColumnFormat('name', 30),\n ColumnFormat('introduced', 12)\n ]) \n for line in lines: \n print(line)","def listusers():\n\n try:\n users = User.query.order_by(User.email).all()\n click.echo(\n tabulate(\n [\n [u.username, u.email, \"admin\" if u.is_admin else None]\n for u in users\n ]\n )\n )\n except OperationalError:\n click.echo(\"Tabela de usuários inexistente...\")","def welcome_user():\n print('Welcome to the Brain Games!')\n name = prompt.string('May I have your name? ')\n print('Hello, {0}!'.format(name)) # noqa: WPS421\n return name","def list_users():\n\n db_users = User.query.all()\n\n return render_template(\"list_users.html\", headline=\"Blogly Users\", users=db_users)","def greeting_message(name):\n print('My name is ' + name)","def user_list(message=''):\n return Response(render_template('admin/user/list.html',\n users=User.query.all(),\n message=message),\n mimetype='text/html')","def welcome(self):\n print(\"\\t\\t\\t\\t\\t============================\")\n print(\"\\t\\t\\tWelcome to Shakespeare's Phrase Hunter!\"\n \"\\n\\t\\t\\tYou will be tested on your Shakespeare knowledge with various \"\n \"\\n\\t\\t\\tphrases from his writings.\")\n print(\"\\t\\t\\t\\t\\t============================\")","def say_hi(self):\n print(\"Hi there, everyone!\")","def __ui_list_all_persons(self):\n persons_list = self.__person_service.service_get_persons_list()\n\n if len(persons_list) == 0:\n print(\"The list of persons is empty!\")\n else:\n print(\"The list of persons in your agenda:\")\n for person in persons_list:\n print(\" \" + str(person))\n print(\"\")","def view_users(stdscr):\n stdscr.clear()\n safe_put(stdscr, \"* marks a user online at last update. Hit any key to return to menu.\", (2, 1))\n row = 4\n for user in taunet.users.all():\n if user.is_on:\n safe_put(stdscr, \"*\", (row, 1))\n safe_put(stdscr, user.name, (row, 3))\n row += 1\n stdscr.refresh()\n\n # Wait for any key, then clear and return to menu.\n stdscr.getch()\n stdscr.clear()\n stdscr.refresh()","def main():\n data = get_db()\n myCursor = data.cursor()\n myCursor.execute(\"SELECT * FROM users\")\n description = [desc[0] for desc in myCursor.description]\n\n logger = get_logger()\n\n for user in myCursor:\n userInfo = \"\".join(\n f'{des}={str(usr)}; ' for usr, des in zip(user, description)\n )\n logger.info(userInfo)\n\n myCursor.close()\n data.close()","def describe_user(self):\r\n print('\\nFirst Name: ' + self.first_name.title(), end='\\n',)\r\n print('Last Name: ' + self.last_name.title(), end='\\n')\r\n print('Address: ' + self.address.title(), end='\\n',)\r\n print('State: ' + self.state.title(), end='\\n',)\r\n print('Country: ' + self.country.title())","def greet_player(name):\n\t\n\tprint \"How are are you doing %s?\" % name","def show_users():\r\n users = User.query.order_by(User.last_name,User.first_name).all()\r\n return render_template('list.html', users=users)","def greet(*args):\n print(greet.__doc__)\n # names is a tuple with arguments\n for name in args:\n print(\"Hello\", name)"],"string":"[\n \"def greet_users(names):\\n for name in names:\\n msg = \\\"Hello, \\\" + name.title() + \\\"!\\\"\\n print(msg)\",\n \"def greet_users(names):\\n for name in names:\\n msg = \\\"Hello, \\\" + name.title() + \\\"!\\\"\\n print(msg)\",\n \"def greet_users(names):\\n for name in names:\\n print(f\\\"Hello, {name.title()}!\\\")\",\n \"def greeting(list_of_guests):\\r\\n for i in list_of_guests: \\r\\n print('Witaj ' + i)\",\n \"def greet_users(names):\\n for name in names:\\n msg = f\\\"Hello, {name.title()}\\\"\\n print(msg)\",\n \"def greet_users(names):\\n for name in names:\\n msg = f\\\"Hello, {name.title()}!\\\"\\n print(msg)\",\n \"def greet_users(names):\\n for name in names:\\n msg = f\\\"Hello, {name.title()}!\\\"\\n print(msg)\",\n \"def print_users(self):\\n for i, item in enumerate(self.users):\\n print(\\\"{}. {}\\\".format(i, item.name))\",\n \"def greet_user(self):\\n print(\\\"Hello, \\\" + self.first_name.title() + \\\" \\\" + self.last_name.title() + \\\"!\\\")\",\n \"def greet_user(self):\\n print(\\\"Hello \\\" + self.first_name.title() + \\\" \\\" +\\n self.last_name.title() + \\\", welcome back!\\\")\",\n \"def greet_user(self):\\n print(\\\"Welcome, \\\" + self.first_name.title() + \\\"!\\\")\",\n \"def greet_user(self):\\r\\n\\r\\n print(\\\"Hello \\\" + self.first_name.title() + \\\" \\\" + self.last_name.title() + \\\".\\\")\",\n \"def greet_user(self):\\n greeting = f\\\"Hi {self.first_name.title()}, welcome back!\\\\n\\\"\\n print(greeting)\",\n \"def greet_user(self):\\n print(\\\"\\\\nWelcome, \\\" + self.username + \\\"!\\\")\",\n \"def greet_user(self):\\n print(\\\"\\\\nWelcome, \\\" + self.username + \\\"!\\\")\",\n \"def greet_user(self):\\r\\n\\t\\tprint(f\\\"\\\\nHello {self.first_name}!\\\\n\\\")\",\n \"def greet_user(self):\\n print(\\\"Hello \\\" + self.f_name.title() + \\\"!, hope you're well today!\\\")\",\n \"def greet_user(username):\\r\\n print(f\\\"Hello, {username.title()}!\\\")\",\n \"def greet_user(self):\\n\\t\\tprint(f\\\"How are you doing {self.first_name.title()}?\\\")\",\n \"def greet_user():\\r\\n print('Hi,' + FirstName + ' ' + LastName + ' thanks for joining us inside the beer app!')\",\n \"async def _welcome(self, ctx, *, users: discord.User = None):\\n if not users:\\n await ctx.send(f\\\"Welcome {ctx.author.mention} to {ctx.guild.name}!\\\")\\n else:\\n if len(users) > 1:\\n users = humanize_list(users)\\n else:\\n users = users[0].mention\\n await ctx.send(f\\\"Welcome {users} to {ctx.guild.name}!\\\")\",\n \"def print_users(self):\\n for user in self.users.values():\\n print(user)\",\n \"def greet_user(self):\\n print(f\\\"Hiya {self.username}!\\\")\",\n \"def greet_user(username):\\n print(\\\"Hello, \\\" + username.title() + \\\"!\\\")\",\n \"def greet_user(username):\\n print(\\\"Hello, \\\" + username.title() + \\\"!\\\")\",\n \"def greet_user(username):\\r\\n print(\\\"Hello, \\\" + username + \\\"!\\\")\",\n \"def greeter_user(username):\\n print(f\\\"Hello {username}\\\")\",\n \"def greet_user(username):\\n print(\\\"Hello, \\\" + username + \\\"!\\\")\",\n \"def greet_user(self):\\n print(\\\"Greatings \\\"+ self.first_name + \\\" \\\" + self.last_name +\\\", welcome to the matrix.\\\")\",\n \"def greet_user():\\n print(\\\"Hello\\\")\",\n \"def greeting(players_name):\\n print \\\"\\\\nGreat! Welcome, \\\" + players_name + \\\". The purpose of this game is to fill in the blanks for all the sentences provided.\\\"\",\n \"def greet_user():\\n username = get_user()\\n\\n if username:\\n print(f\\\"Välkommen tillbaks {username.title()}!!\\\")\\n else:\\n username = create_new_user()\\n print(f\\\"Vi kommer ihåg dig när du återvänder {username}\\\")\",\n \"def greet_username(username):\\n print(\\\"Hello, \\\" + username.title() + \\\"!\\\")\",\n \"async def greeting(self, ctx):\\n await self.bot.say('hello {0.name}'.format(ctx.message.author))\",\n \"def greet_user():\\n print(\\\"Hello!\\\")\",\n \"def greet_user():\\n print(\\\"Hello!\\\")\",\n \"def greet_user():\\n print(\\\"Hello!\\\")\",\n \"def greet(*names):\\n print(names)\\n for name in names:\\n print(' Hello {0}!'.format(name))\",\n \"def list_users(item):\\n users = User.load_all_users(item)\\n for user in users:\\n print(user.username)\",\n \"def show_greeting(self):\\n self.output(' ------------------------ ')\\n self.output('You are now playing ' + self.name)\\n self.output(self.greeting)\\n self.output(' ------------------------ ')\",\n \"def welcome_user():\\n welcome_string = 'Welcome to the brain Brain Games!\\\\n'\\n print(welcome_string)\\n name = prompt.string('May I have your name? ')\\n print('{0}, {1}!'.format('Hello', name))\",\n \"def greet_user():\\r\\n print(\\\"hello!\\\")\",\n \"def greet_user():\\n username = get_stored_username()\\n if username:\\n print(\\\"Welcome back, \\\" + username['Name'] + \\\"!\\\")\\n else:\\n username = get_new_username()\\n print(\\\"We'll remember you when you come back, \\\" + username + \\\"!\\\")\",\n \"def __list_all_users(self):\\n\\n usernames_dict = get_data.get_usernames_dict()\\n if len(usernames_dict) > 0:\\n first_str = 'user'\\n second_str = 'posts scraped'\\n descriptor = '{:<40} {}'\\n print('')\\n print(descriptor.format(first_str, second_str))\\n print(descriptor.format(len(first_str) * '-', len(second_str) * '-'))\\n for number, username in usernames_dict.items():\\n space_str = ' ' if len(str(number)) > 1 else ' '\\n first = '[' + space_str + str(number) + '] ' + username\\n second = str(get_data.get_user_post_count(username))\\n print(descriptor.format(first, second))\\n else:\\n print('no users found in the database')\",\n \"def greeting(self):\\n print(\\\"Hello! My name is {name}.\\\".format(name=self.name))\",\n \"def greeting(self):\\n print(\\\"Hello! My name is {name}.\\\".format(name=self.name))\",\n \"def greet_user():\\n username = load_user_data()\\n if username != None:\\n print(\\\"Welcome back, \\\" + username)\\n else:\\n register_user()\",\n \"def greeting(name, message):\\n print(f'Hello {name}!')\\n print(message)\",\n \"def user_list(server_object, client, address, command_args):\\n\\n\\tmsg = \\\"\\\"\\n\\n\\t#: Create a formatted string of all the users.\\n\\tfor usr in server_object.usrs.values():\\n\\t\\tmsg += usr + '\\\\n'\\n\\n\\tclient.send(msg.encode())\",\n \"def list_users():\\n\\n users = User.query.order_by(\\\"last_name\\\").all()\\n return render_template(\\\"users/user_list.html\\\", users=users)\",\n \"def list_users():\\n users = User.query.order_by(User.last_name, User.first_name).all()\\n return render_template('index.html', users=users)\",\n \"def home_list():\\n\\tui.lst1()\\n\\tui.lst2()\\n\\tx = db.get_users()\\n\\tfor i in x:\\n\\t\\tz = len(i[1])\\n\\t\\tf = 16-z\\n\\t\\tl = \\\" \\\"*f\\n\\t\\tprint i[1], l, i[4],l,i[5]\\n\\traw_input(\\\"Press [enter] to goto homescreen\\\")\\n\\thome()\",\n \"def show_users():\\n return 'hehe'\",\n \"def greet_user(name = 'Menoetius'):\\n print(\\\"Hello, my name is \\\" + name.title() + \\\"!\\\")\",\n \"def welcome():\\n name = prompt.string('May I have your name? ')\\n print(f'Hello, {name}!') # noqa: WPS421\",\n \"def greeting(name):\\n print(\\\"\\\")\\n print(\\n \\\"Welcome to Mister Sweet's Mad Lib Story Telling Journey \\\" + name +\\n \\\" :)\\\")\\n print(\\\"\\\")\",\n \"def show():\\n return render_template(\\n 'listUsers.html',\\n title='List Users',\\n message='These are the users in our system'\\n )\",\n \"def greet_user():\\n\\tusername = get_stored_username()\\n\\tif username:\\n\\t\\tprint(\\\"Welcome back, \\\" + username + \\\"!\\\")\\n\\telse:\\n\\t\\tusername = get_new_username()\\n\\t\\tprint(\\\"We'll remember you when you come back, \\\" + username + \\\"!\\\")\",\n \"def do_list_users(self, line):\\n users = self.protocol.cmd_list_users(exp=line, return_list=True)\\n t = PrettyTable(users[0])\\n for u in users[1:]:\\n t.add_row(u)\\n print(t)\",\n \"def greet_guest():\\n print('Welcome')\",\n \"def greeting():\\n print('\\\\n',\\n '=' * 45,\\n \\\"\\\\n Welcome to this Module-Creation-Test-Program!!!\\\",\\n '\\\\n',\\n '=' * 45)\",\n \"def _list_users(self):\\n users = fileIO.load_json(\\\"users.json\\\")\\n print(\\\"The list of users is as follows:\\\")\\n for i in users:\\n print(users[i][\\\"name\\\"])\\n self._list_user_settings(users)\",\n \"def user_list():\\n\\n users = User.query.all()\\n\\n return render_template(\\\"user_list.html\\\", users=users)\",\n \"def display_list(the_list):\\n print(\\\"\\\\n===================================\\\")\\n for person in the_list:\\n print(\\\"{name:12s}\\\\t\\\\t{phone}\\\".format(name=person.name, phone=person.phone))\\n if the_list == []:\\n print(\\\"\\\\nNo entries found!\\\\n\\\")\\n print(\\\"===================================\\\\n\\\")\",\n \"def printusers(self, irc, msg, args):\\n irc.reply(self.user_report(), prefixNick=False)\",\n \"def user_list():\\n\\n users = User.query.all()\\n return render_template(\\\"user_list.html\\\", users=users)\",\n \"def user_list():\\n\\n users = User.query.all()\\n return render_template(\\\"user_list.html\\\", users=users)\",\n \"def user_list():\\n\\n users = User.query.all()\\n return render_template(\\\"user_list.html\\\", users=users)\",\n \"def user_list():\\n\\n users = User.query.all()\\n return render_template(\\\"user_list.html\\\", users=users)\",\n \"def user_list():\\n\\n users = User.query.all()\\n return render_template(\\\"user_list.html\\\", users=users)\",\n \"def user_list():\\n\\n users = User.query.all()\\n return render_template(\\\"user_list.html\\\", users=users)\",\n \"def user_list_all(message=''):\\n return Response(render_template('employee/user/list.html',\\n users=User.query.all(),\\n message=message),\\n mimetype='text/html')\",\n \"def user_list(ctx):\\n data = ctx.obj.get_all_users()\\n output_json_data(data)\",\n \"def list_users(self, user=None):\\n from expfactory.database.models import Participant\\n\\n participants = Participant.query.all()\\n users = []\\n for user in participants:\\n users.append(self.print_user(user))\\n return users\",\n \"def guestlist_handler(userdata, *args):\\n\\t\\tfor guest in userdata[\\\"guestlist\\\"]:\\n\\t\\t\\tprint(shlex.quote(guest), end=\\\" \\\")\\n\\t\\t\\n\\t\\tprint()\",\n \"def user_list():\\n\\n users = User.query.all()\\n \\n return render_template(\\\"user_list.html\\\", users=users)\",\n \"async def tod_list(self, ctx, *args):\\n message = \\\"__Currently Playing__\\\\n\\\"\\n if len(self.players) == 0:\\n message = \\\"There are currently no users playing.\\\"\\n for player in self.players:\\n message += f\\\"> {str(player)[:-5]}\\\\n\\\"\\n await ctx.send(message)\",\n \"def do_user_list(cs, args):\\n _, users = cs.users.list()\\n fields = ['user_id', 'username', 'email', 'realname', 'comment']\\n utils.print_list(users, fields, sortby=args.sortby)\",\n \"def print_user_host(host_list, user, ul):\\n \\n print('\\\\nHost-group info pertaining to {0}:'.format(user))\\n print('-'.center(80, '-'))\\n if len(ul) == 0:\\n print('User is not a member of any user-lists.')\\n else:\\n print('User belongs to the following user-lists:')\\n for u in ul:\\n print(u)\\n print()\\n print('User has access to the following host-groups:')\\n for hg in host_list:\\n print(hg)\\n print('-'.center(80, '-') + '\\\\n')\\n return\",\n \"def user_list():\\n\\n users = User.query.all()\\n return render_template(\\\"/user_list.html\\\", users=users)\",\n \"async def list_users(self, ctx):\\n \\n path = \\\"Users\\\"\\n headers = {\\n 'accept': 'application/json'\\n }\\n response = send_request(method=\\\"get\\\", path=path, headers=headers)\\n users = []\\n for page in response:\\n users.append(f\\\"**{page['Name']}**: ``{page['Id']}``\\\")\\n log.debug(users)\\n\\n embed = embeds.make_embed(ctx=ctx, title=\\\"List Users\\\", image_url=\\\"https://emby.media/resources/logowhite_1881.png\\\")\\n\\n await LinePaginator.paginate([line for line in users], ctx, embed, restrict_to_user=ctx.author)\",\n \"def describe_user(self):\\n\\t\\tprint(f\\\"\\\\n{self.first_name.title()} {self.last_name.title()} \\\"\\n\\t\\t\\tf\\\"is from {self.location.title()}.\\\")\",\n \"def greet_user():\\n\\tusername = get_stored_username()\\n\\tif username:\\n\\t\\tprint(f\\\"WElcome back {username}!\\\")\\n\\telse:\\n\\t\\tusername = get_new_username()\\n\\t\\tprint(f\\\"We'll remember you when you come back again {username}! \\\")\",\n \"def list( self, mess, args):\\n user = self.get_sender_username(mess)\\n args = args.replace(' ', '_')\\n if user in self.users:\\n user_list = 'All these users are subscribed - \\\\n'\\n user_list += '\\\\n'.join(['%s :: %s' %(u, self.users[u]) for u in sorted(self.users)])\\n if self.invited.keys():\\n user_list += '\\\\n The following users are invited - \\\\n'\\n user_list += '\\\\n'.join(self.invited.keys())\\n self.log.info( '%s checks list of users.' % user)\\n return user_list\",\n \"def user_list(message=''):\\n target_users = User.query.filter_by(name=request.form['name']).all()\\n\\n if not any(target_users):\\n return search_user(\\\"Unknown user.\\\")\\n\\n return Response(render_template('employee/user/list.html',\\n users=target_users,\\n message=message),\\n mimetype='text/html')\",\n \"def do_list(self, arg):\\n print('The roster includes the following members:\\\\n')\\n lines = formatTable(\\n map(self.memberToList, self.roster),\\n [\\n ColumnFormat('id', 4),\\n ColumnFormat('name', 30),\\n ColumnFormat('introduced', 12)\\n ]) \\n for line in lines: \\n print(line)\",\n \"def listusers():\\n\\n try:\\n users = User.query.order_by(User.email).all()\\n click.echo(\\n tabulate(\\n [\\n [u.username, u.email, \\\"admin\\\" if u.is_admin else None]\\n for u in users\\n ]\\n )\\n )\\n except OperationalError:\\n click.echo(\\\"Tabela de usuários inexistente...\\\")\",\n \"def welcome_user():\\n print('Welcome to the Brain Games!')\\n name = prompt.string('May I have your name? ')\\n print('Hello, {0}!'.format(name)) # noqa: WPS421\\n return name\",\n \"def list_users():\\n\\n db_users = User.query.all()\\n\\n return render_template(\\\"list_users.html\\\", headline=\\\"Blogly Users\\\", users=db_users)\",\n \"def greeting_message(name):\\n print('My name is ' + name)\",\n \"def user_list(message=''):\\n return Response(render_template('admin/user/list.html',\\n users=User.query.all(),\\n message=message),\\n mimetype='text/html')\",\n \"def welcome(self):\\n print(\\\"\\\\t\\\\t\\\\t\\\\t\\\\t============================\\\")\\n print(\\\"\\\\t\\\\t\\\\tWelcome to Shakespeare's Phrase Hunter!\\\"\\n \\\"\\\\n\\\\t\\\\t\\\\tYou will be tested on your Shakespeare knowledge with various \\\"\\n \\\"\\\\n\\\\t\\\\t\\\\tphrases from his writings.\\\")\\n print(\\\"\\\\t\\\\t\\\\t\\\\t\\\\t============================\\\")\",\n \"def say_hi(self):\\n print(\\\"Hi there, everyone!\\\")\",\n \"def __ui_list_all_persons(self):\\n persons_list = self.__person_service.service_get_persons_list()\\n\\n if len(persons_list) == 0:\\n print(\\\"The list of persons is empty!\\\")\\n else:\\n print(\\\"The list of persons in your agenda:\\\")\\n for person in persons_list:\\n print(\\\" \\\" + str(person))\\n print(\\\"\\\")\",\n \"def view_users(stdscr):\\n stdscr.clear()\\n safe_put(stdscr, \\\"* marks a user online at last update. Hit any key to return to menu.\\\", (2, 1))\\n row = 4\\n for user in taunet.users.all():\\n if user.is_on:\\n safe_put(stdscr, \\\"*\\\", (row, 1))\\n safe_put(stdscr, user.name, (row, 3))\\n row += 1\\n stdscr.refresh()\\n\\n # Wait for any key, then clear and return to menu.\\n stdscr.getch()\\n stdscr.clear()\\n stdscr.refresh()\",\n \"def main():\\n data = get_db()\\n myCursor = data.cursor()\\n myCursor.execute(\\\"SELECT * FROM users\\\")\\n description = [desc[0] for desc in myCursor.description]\\n\\n logger = get_logger()\\n\\n for user in myCursor:\\n userInfo = \\\"\\\".join(\\n f'{des}={str(usr)}; ' for usr, des in zip(user, description)\\n )\\n logger.info(userInfo)\\n\\n myCursor.close()\\n data.close()\",\n \"def describe_user(self):\\r\\n print('\\\\nFirst Name: ' + self.first_name.title(), end='\\\\n',)\\r\\n print('Last Name: ' + self.last_name.title(), end='\\\\n')\\r\\n print('Address: ' + self.address.title(), end='\\\\n',)\\r\\n print('State: ' + self.state.title(), end='\\\\n',)\\r\\n print('Country: ' + self.country.title())\",\n \"def greet_player(name):\\n\\t\\n\\tprint \\\"How are are you doing %s?\\\" % name\",\n \"def show_users():\\r\\n users = User.query.order_by(User.last_name,User.first_name).all()\\r\\n return render_template('list.html', users=users)\",\n \"def greet(*args):\\n print(greet.__doc__)\\n # names is a tuple with arguments\\n for name in args:\\n print(\\\"Hello\\\", name)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7735355","0.7735355","0.7734715","0.77266586","0.77149934","0.7699153","0.7699153","0.73098725","0.7258156","0.7245961","0.7140347","0.7128372","0.712475","0.70942545","0.70942545","0.7049544","0.7025611","0.69582665","0.6946257","0.68995595","0.6774867","0.67537284","0.67523855","0.67104477","0.67104477","0.664824","0.6625492","0.6617733","0.6607957","0.6600291","0.65322846","0.6511558","0.638695","0.63431704","0.633322","0.633322","0.633322","0.6316655","0.6304312","0.6295764","0.6288711","0.6281444","0.6264973","0.6261719","0.62063074","0.62063074","0.61737853","0.61248803","0.61212564","0.6119068","0.6117569","0.6106639","0.61062944","0.61011934","0.6084502","0.6073184","0.60647607","0.6060699","0.6051846","0.6017174","0.60155207","0.60022527","0.6001032","0.59994704","0.59963125","0.59945047","0.59945047","0.59945047","0.59945047","0.59945047","0.59945047","0.5993746","0.5990611","0.5990506","0.59870684","0.5981488","0.59787923","0.5975094","0.5969313","0.59509486","0.59488666","0.5942349","0.59376466","0.5932266","0.5925974","0.59161043","0.59083134","0.59038854","0.59020805","0.5888565","0.5882718","0.5856239","0.58539915","0.5849538","0.58381635","0.58374834","0.5830967","0.5815728","0.58147794","0.5807836"],"string":"[\n \"0.7735355\",\n \"0.7735355\",\n \"0.7734715\",\n \"0.77266586\",\n \"0.77149934\",\n \"0.7699153\",\n \"0.7699153\",\n \"0.73098725\",\n \"0.7258156\",\n \"0.7245961\",\n \"0.7140347\",\n \"0.7128372\",\n \"0.712475\",\n \"0.70942545\",\n \"0.70942545\",\n \"0.7049544\",\n \"0.7025611\",\n \"0.69582665\",\n \"0.6946257\",\n \"0.68995595\",\n \"0.6774867\",\n \"0.67537284\",\n \"0.67523855\",\n \"0.67104477\",\n \"0.67104477\",\n \"0.664824\",\n \"0.6625492\",\n \"0.6617733\",\n \"0.6607957\",\n \"0.6600291\",\n \"0.65322846\",\n \"0.6511558\",\n \"0.638695\",\n \"0.63431704\",\n \"0.633322\",\n \"0.633322\",\n \"0.633322\",\n \"0.6316655\",\n \"0.6304312\",\n \"0.6295764\",\n \"0.6288711\",\n \"0.6281444\",\n \"0.6264973\",\n \"0.6261719\",\n \"0.62063074\",\n \"0.62063074\",\n \"0.61737853\",\n \"0.61248803\",\n \"0.61212564\",\n \"0.6119068\",\n \"0.6117569\",\n \"0.6106639\",\n \"0.61062944\",\n \"0.61011934\",\n \"0.6084502\",\n \"0.6073184\",\n \"0.60647607\",\n \"0.6060699\",\n \"0.6051846\",\n \"0.6017174\",\n \"0.60155207\",\n \"0.60022527\",\n \"0.6001032\",\n \"0.59994704\",\n \"0.59963125\",\n \"0.59945047\",\n \"0.59945047\",\n \"0.59945047\",\n \"0.59945047\",\n \"0.59945047\",\n \"0.59945047\",\n \"0.5993746\",\n \"0.5990611\",\n \"0.5990506\",\n \"0.59870684\",\n \"0.5981488\",\n \"0.59787923\",\n \"0.5975094\",\n \"0.5969313\",\n \"0.59509486\",\n \"0.59488666\",\n \"0.5942349\",\n \"0.59376466\",\n \"0.5932266\",\n \"0.5925974\",\n \"0.59161043\",\n \"0.59083134\",\n \"0.59038854\",\n \"0.59020805\",\n \"0.5888565\",\n \"0.5882718\",\n \"0.5856239\",\n \"0.58539915\",\n \"0.5849538\",\n \"0.58381635\",\n \"0.58374834\",\n \"0.5830967\",\n \"0.5815728\",\n \"0.58147794\",\n \"0.5807836\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7658193"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":76297,"cells":{"query":{"kind":"string","value":"Start a combat, make all NPCs to cast skills automatically."},"document":{"kind":"string","value":"def start_combat(self):\n super(HonourAutoCombatHandler, self).start_combat()\n\n # All characters auto cast skills.\n for char in self.characters.values():\n character = char[\"char\"]\n character.start_auto_combat_skill()"},"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 StartCombat(self):\n\n print(\"------------------------------------\")\n self.fighter1.PrintInfo()\n self.fighter2.PrintInfo()\n print(\"------------------------------------\")\n self.combatInProgress = True\n while self.combatInProgress and self.currentTurn < self.maxTurns:\n print(\"Turn {}:\".format(self.currentTurn))\n self.CombatAttack()\n if self.EndTurn():\n print(\"------------------------------------\")\n break\n print(\"------------------------------------\")\n time.sleep(3)","def run_combat(self, monster1, monster2):\n\n ce = combat_engine.CombatEngine(monster1, monster2, log_ref=self)\n ce.run_combat()","def begin_encounter(self):\r\n\r\n #introduce NPCs - run all introduce methods, unless the NPCs have the same name\r\n for i in range(len(self.npc_names)):\r\n for _npc in self.npc_list:\r\n if _npc.name == self.npc_names[i]:\r\n _npc.introduce(self.npc_quantities[i], self.location)\r\n break\r\n\r\n #list visible enemies\r\n self.display_npcs()\r\n\r\n #check close proximity - if hostile enemy within 10 ft, don't go to interact menu\r\n hostile_close_proximity = False\r\n \r\n for m in range(len(self.npc_distances)):\r\n if self.npc_distances[m] < 10:\r\n if self.npc_list[m].hostility == utils.HostilityLevel.HOSTILE:\r\n hostile_close_proximity = True\r\n multiple = self.npc_quantities[self.npc_names.index(self.npc_list[m].name)] > 1\r\n self.npc_list[m].alert_close_proximity(multiple)\r\n break\r\n\r\n interaction_result = NextState\r\n \r\n if hostile_close_proximity:\r\n #start combat\r\n interaction_result = NextState.COMBAT\r\n else:\r\n #run interaction choice menu - interactions may return flags that spawn social/combat encounters\r\n print(\"Select NPC to interact with:\")\r\n for l in range(len(self.npc_list)):\r\n print(str(l + 1) + \". \" + self.npc_list[l].name + \" (Distance: \" + str(self.npc_distances[l]) + \"ft.)\")\r\n \r\n choice = 0\r\n while choice < 1 or choice > len(self.npc_names) + 1:\r\n try:\r\n choice = int(input(\"Make selection: \"))\r\n except:\r\n print(\"Enter an integer between 1 and \" + str(len(self.npc_names)))\r\n \r\n interaction_result = self.npc_list[choice - 1].interact(self, choice - 1, self.main_player)\r\n\r\n #spawn social/combat encounter\r\n #if combat, pass npc list to generate turn order\r\n if interaction_result.name == \"COMBAT\":\r\n #spawn combat encounter\r\n print(\"Starting combat\")\r\n new_combat = combat.CombatEncounter(self.main_player, self.npc_list, self.npc_distances, self.npc_quantities)\r\n elif interaction_result.name == \"SOCIAL\":\r\n #spawn social encounter\r\n print(\"Starting social encounter\")\r\n elif interaction_result.name == \"FINISHED\":\r\n #present next choices, award loot from area\r\n #allow player to interact with any remaining/new NPCs\r\n print(\"Encounter finished\")\r\n elif interaction_result.name == \"DEATH\":\r\n #kill the player and end the game\r\n print(\"Player dead\")","def start(self):\n self.startAngMovementALl()\n self.startMovementAll()","def _starting_up():\n global ws, skill_reload_thread, event_scheduler\n\n ws.on('intent_failure', FallbackSkill.make_intent_failure_handler(ws))\n\n # Create skill_manager listener and invoke the first time\n ws.on('skill_manager', skills_manager)\n ws.on('mycroft.internet.connected', install_default_skills)\n ws.emit(Message('skill_manager', {}))\n\n # Create the Intent manager, which converts utterances to intents\n # This is the heart of the voice invoked skill system\n\n PadatiousService(ws)\n IntentService(ws)\n event_scheduler = EventScheduler(ws)\n # Create a thread that monitors the loaded skills, looking for updates\n skill_reload_thread = WatchSkills()\n skill_reload_thread.daemon = True\n skill_reload_thread.start()\n\n # Wait until skills have been loaded once before starting to check\n # network connection\n skill_reload_thread.wait_loaded_priority()\n check_connection()","def use_skill(self, g, i, x, y):\n # @ param g a reference to the game engine\n # @ param i the index of the skill (basically what skill)\n # @ param x the x target coordinate in game pixels\n # @ param y the y target coordinate in game pixels\n if self.attackTimer < self.attackDelay:\n print(\"attack on CD\")\n return\n \n if self.skill[i].skillAttr == 0:\n g.fire_skill_sound.play()\n elif self.skill[i].skillAttr == 1:\n g.ice_skill_sound.play()\n elif self.skill[i].skillAttr == 2:\n g.lightning_skill_sound.play()\n elif self.skill[i].skillAttr == 3:\n g.poison_skill_sound.play()\n \n \n if self.skill[i].skillKey == 0: #Aura\n #turn the aura on/off\n if self.skill[i].active == False:\n #print(\"aura on\")\n self.skill[i].active = True\n else:\n self.skill[i].active = False\n #print(\"aura off\")\n \n elif self.skill[i].skillKey == 1: #Missile\n if self.mana[0] > self.skill[i].skillCost:\n self.mana[0] -= self.skill[i].skillCost\n self.attackTimer = 0\n target = Target(x, y)\n center_x = self.rect.x + (self.rect.width / 2)\n center_y = self.rect.y + (self.rect.height / 2)\n #bullet types: fire 5, ice 6, lightning 7\n #skill types: fire 0, ice 1, lightning 2\n g.bullets.append(self.bulletFactory.createBullet(g, self.skill[i].skillAttr + 5, 0, self.attack, 1024, target, center_x, center_y))\n #print(\"missile\")\n\n elif self.skill[i].skillKey == 2: #Breath\n #for each creep in the AoE cone, do damage.\n if self.mana[0] > self.skill[i].skillCost:\n self.mana[0] -= self.skill[i].skillCost\n self.attackTimer = 0\n #get low and high angle (-45 degrees and +45 degrees from player -> point angle)\n lowAngle = math.atan2(y - self.rect.centery, x - self.rect.centerx) - 3.1415 / 2.0\n highAngle = math.atan2(y - self.rect.centery, x - self.rect.centerx) + 3.1415 / 2.0\n for creep in g.creeps:\n #get angle to creep\n creepAngle = math.atan2(creep.rect.centery - self.rect.centery, creep.rect.centerx - self.rect.centerx)\n \n #if angle to the creep is between the two angles\n if creepAngle > lowAngle and creepAngle < highAngle:\n #and the distance to the creep is below the skill's range\n if ( (creep.rect.centerx - self.rect.centerx) ** 2 + (creep.rect.centery - self.rect.centery) ** 2 ) ** 0.5 < 4 * 24:\n creep.take_damage( self.attack )\n #print(\"breath\")\n #apply debuffs, based on type\n if self.skill[i].skillAttr == 0: #fire\n creep.applyBurning()\n elif self.skill[i].skillAttr == 1: #frost\n creep.applyChilled()\n elif self.skill[i].skillAttr == 2: #lightning\n creep.applyShocked()","def startBattle(self):\n defender = self.map.getUnitAt(self.pos)\n attacker = self.selectedUnit\n defender.takeDamage(int(attacker.firepower * attacker.hp))\n attacker.takeDamage(int(defender.firepower * defender.hp))\n self.endBattle()","def start_soundtrack(self):\n sources = screens['Combat']['music']\n self.source = choice(sources)\n Logger.info(\n 'Application: Chose \"{}\" as the combat music.'.format(self.source)\n )\n try:\n SoundManager.music[self.source]\n except KeyError:\n SoundManager.add_music(self.source, self)\n SoundManager.play_music(self.source)","def _starting_up():\n global bus, skill_manager, event_scheduler\n\n bus.on('intent_failure', FallbackSkill.make_intent_failure_handler(bus))\n\n # Create the Intent manager, which converts utterances to intents\n # This is the heart of the voice invoked skill system\n service = IntentService(bus)\n try:\n PadatiousService(bus, service)\n except Exception as e:\n LOG.exception('Failed to create padatious handlers '\n '({})'.format(repr(e)))\n event_scheduler = EventScheduler(bus)\n\n # Create a thread that monitors the loaded skills, looking for updates\n try:\n skill_manager = SkillManager(bus)\n except MsmException:\n # skill manager couldn't be created, wait for network connection and\n # retry\n LOG.info('Msm is uninitialized and requires network connection',\n 'to fetch skill information\\n'\n 'Waiting for network connection...')\n while not connected():\n time.sleep(30)\n skill_manager = SkillManager(bus)\n\n skill_manager.daemon = True\n # Wait until priority skills have been loaded before checking\n # network connection\n skill_manager.load_priority()\n skill_manager.start()\n check_connection()","def game_start():\n herolist = Hero_List(hots_db)\n heroclasses = []\n for item in herolist:\n heroclasses.append(Item(item, 'hero'))\n curgame = Game(Team('home'), Team('enemy'), Team('hero_pool', heroclasses), '')\n return curgame","def start():\r\n introduction()\r\n score = duck_shooting1()\r\n dogs()\r\n play_again(score)","def start_game(self):\n while self.can_deal:\n self.take_turn()","def start(self):\n\n # Call the protected _turn method to start the game\n self._turn()","def start(self):\n self.player = Player()\n self.dealer = Dealer()\n self.pot = 0\n self.side_bet = 0\n start_game()","def start():\n for m in motors:\n m.run_direct()","def start_game(self):\n self._add_mines()","def finish(self):\n for char in self.characters.values():\n character = char[\"char\"]\n character.stop_auto_combat_skill()\n\n super(HonourAutoCombatHandler, self).finish()","def startGame(self):\n\n\t\tfor name in self.players.keys():\n\t\t\tself.startPlayerGame((name, 0))\n\t\tself.setupGuiSignals()","def exec(self):\n for player_id in range(0, 6):\n ai_command = self.info_manager.get_player_tactic(player_id).exec()\n self.info_manager.set_player_next_action(player_id, ai_command)","def add_skill(skill_list, skill): #inputs the skill dictionary and skill\r\n\tif skill==\"Gun Combat\":\r\n\t\tif stellagama.dice(1,6)>=3:\r\n\t\t\tfor item in guns:\r\n\t\t\t\tif item in skill_list:\r\n\t\t\t\t\tskill=item\r\n\t\t\t\telse:\r\n\t\t\t\t\tskill=stellagama.random_choice(guns)\r\n\t\telse:\r\n\t\t\tskill=stellagama.random_choice(guns)\r\n\telif skill in [\"Blade Combat\", \"Blade Cbt\"]:\r\n\t\tif stellagama.dice(1,6)>=3:\r\n\t\t\tfor item in melee:\r\n\t\t\t\tif item in skill_list:\r\n\t\t\t\t\tskill=item\r\n\t\t\t\telse:\r\n\t\t\t\t\tskill=stellagama.random_choice(melee)\r\n\t\telse:\r\n\t\t\tskill=stellagama.random_choice(melee)\r\n\telif skill==\"Vehicle\":\r\n\t\tif stellagama.dice(1,6)>=3:\r\n\t\t\tfor item in vehicles:\r\n\t\t\t\tif item in skill_list:\r\n\t\t\t\t\tskill=item\r\n\t\t\telse:\r\n\t\t\t\tskill=stellagama.random_choice(vehicles)\r\n\t\telse:\r\n\t\t\tskill=stellagama.random_choice(vehicles)\r\n\tif skill in skill_list:\r\n\t\tskill_list[skill] += 1\r\n\telif skill not in skill_list:\r\n\t\tskill_list[skill] = 1\r\n\treturn skill_list #outputs the skill dictionary\r","def start(self, timed):\n\n if timed:\n self._game = TimedGame(self._players)\n else:\n self._game = Game(self._players)\n \n self._game.start()","async def start(self):\n await self.on_start()\n valid = await self.get_participants()\n\n if valid:\n await asyncio.sleep(1)\n await self.prepare()\n await self.game()\n\n del started[started.index(self.channel.id)]","def start_game(self, discord_id): # TODO replace with actual interface\n\n character = self.known_characters[discord_id]\n self.current_character = character\n character.start_game()\n return character.first_output()","def moove_character(self, case_list):\n\t\tself.actual_hero.start_moove(case_list)","def startDM(self):\n self.uidm.startDM()","def do (combat, investigator, monster):\n if not arkham.SkillCheck (arkham.checkbase_will, -2) \\\n .check (combat.game, investigator, monster):\n arkham.horror_check_fail_hook (combat, investigator, monster)\n arkham.combat_check_fail_hook (combat, investigator, monster)\n arkham.combat_loop_hook (combat, investigator, monster)\n else:\n arkham.normal_fight_hook (combat, investigator, monster)","def startMovementAll(self):\n self.startMovementX()\n self.startMovementY()\n self.startMovementZ()","def start(self):\n self.__init__()\n self.set_n_players()\n self.init_players()\n self.init_territory_selection_phase()\n self.init_troop_deployment_phase()\n # self.game_phase()","def start(self):\n for game_object in self.game_objects:\n game_object.start()\n # end for\n self.time = time.time()\n self.paused = False\n self.running = True\n print 'GAME STARTED'","def start(self):\n # Call the protected _turn method to start the game\n self._end_time = time.time() + 60\n self._turn()","async def on_start(self):\n m = \"**{}** has started a game of {}! To participate, say `I`! **{} players needed.**\".format(\n self.message.author.display_name, self.name, self.num)\n await client.say(self.message, m)","def miner_begin_jumping(self, player):\n\n if self.onGround:\n self.faceTowards(player)\n self.ai_state = AI_JUMPING\n self.ai_counter = 50\n self.jump(self.direction_val*self.max_speed/2, self.max_speed)\n self.changeAnimation('idle', self.direction_id) #TODO: use a jumping animation rather than an idle animation\n self.weapon.update()\n self.weapon.animation.synch_animation_frame(self.animation)\n return\n \n #TODO: other case?","def start_tournament(self):\n cmd = '{}startTournament'.format(self.console)\n self.write_command(cmd)","def spawn(self):\r\n self.direction = utils.RANDOM.random()*math.pi*2 - math.pi\r\n self.redraw_image()\r\n self.speed = 0\r\n self.ammo = self.world.level.DEFAULT_AMMO\r\n self.alive = True\r\n self.kills = 0\r\n \r\n # Find a spawn point.\r\n # This loop might in theory take forever to return. In practice,\r\n # it returns within a reasonable number of iterations\r\n\r\n self.rect.center = self.team.get_spawn_point()\r\n while self.world.is_colliding(self):\r\n self.rect.centerx += utils.RANDOM.choice((-10, 10))\r\n self.rect.centery += utils.RANDOM.choice((-10, 10))\r\n self.rect.clamp_ip(self.world.rect) #never search outside the world\r\n \r\n #location keeps a floating point representation of the center of the\r\n #agent, mirroring the self.rect.center with higher precision.\r\n self.location = self.rect.center\r\n\r\n self.team.stats[\"spawns\"] += 1","def start(self):\n self.save_checkpoint(\"setup\")\n\n logging.info(\"Starting game...\")\n body = render_message(\n \"welcome.html\",\n game_name=self.name,\n night_end=self.night_end.strftime(\"%I:%M %p\"),\n day_end=self.day_end.strftime(\"%I:%M %p\"),\n players=self.game.players,\n )\n self.send_message(mafia.events.PUBLIC, \"%s: Start\" % self.name, body)\n self.game.begin()\n self.started = True\n\n self.save_checkpoint(\"start\")","def do_attack_action(self, attack_action: action.Attack) -> None:\n self.logger.debug(\"Executing action.Attack: %s\", attack_action)\n self.reset_selection()\n # First move the cursor on the attacking unit\n first = MoveCursorAnimation(self.cursor.coord, attack_action.attacking.coord)\n # Then select the attacking unit\n first.next = SelectAndWait(attack_action.attacking.coord)\n # Then move the cursor on the defending unit\n first.next.next = MoveCursorAnimation(attack_action.attacking.coord, attack_action.defending.coord)\n # Finally do the attack\n first.next.next.next = room.RunRoomAsRoot(rooms.BattleAnimation(attack_action.attacking, attack_action.defending))\n self.add_child(first)","def ai(self):\n if not self.alive:\n return\n\n assert hasattr(self, 'net'), \"Bird has ai enabled but does not appear to have any agents\"\n\n self.birth_time += 1\n\n activation = self.net.activate(self.get_inputs())[0]\n\n # if activation > 1e3:\n # print('unusually high activation of', activation)\n\n if activation > 0.9:\n self.flap()","def start(self) -> None:\n\n while True:\n timetable = []\n for bot in self.bots:\n timetable.append(bot.next_send_time)\n\n val, idx = min((val, idx) for (idx, val) in enumerate(timetable))\n sleep_time = val - time.time()\n\n if sleep_time > 0:\n print(f\"Sleep for: {sleep_time}\")\n time.sleep(sleep_time)\n self.bots[idx].start()","def play_game(self):\n player = Player(input(\"What is your name?\"))\n while player.health > 0:\n input(\"Press t to start another turn\")\n n = random.randint(0, 3)\n if n == 0:\n if self.monster_attack(player):\n break\n elif n == 1:\n self.find_gold(player)\n else:\n print(\"Nothing happened!\")","def testrandom(self):\n for i in range(100):\n WeaponAbility()","def start_game(self):\n\n\t\tpass","def _skills_manager_dispatch():\n global ws\n ws.emit(Message(\"skill_manager\", {}))","async def ai(self, interaction: discord.Interaction, button: discord.ui.Button):\n\t\tself.players.append(BattleshipAI(self.ctx.guild.me.display_name))\n\t\tself.start.disabled = False\n\t\tif len(self.players) >= self.max_players:\n\t\t\tview = None\n\t\t\tself.stop()\n\t\telse:\n\t\t\tview = self\n\t\tawait interaction.response.edit_message(content=self.generate_message(), view=view)","def play(self):\n self._play(self._move_person)","def start_game(self) -> None:\n self.init_game()\n self.play()","def start_game(self) -> None:\n if self.started and not self.finished:\n self.finish_game()\n \n self.started = True\n self.finished = False\n\n self.game_count += 1\n self.games_list[self.game_index] = {\n \"total_kills\": 0,\n \"players\": [],\n \"kills\": {}\n }\n\n return","def __initSkills(self):\n skills = self.teamparser.getPlayerSkills()\n try:\n skills = skills[(self.team, self.position)] #initial skills\n except KeyError, err:\n skills = []\n raise TypeError, \"Invalid Team/Position: \" + self.team\n for skill in skills:\n skobj = pyBBSkill.BBSkill(skill, self.skillparser)\n self.skills.append(skobj)","def play_game(self):\n # need everyone to pass to move to next phase?\n self.deal_cards()\n self.plant_food()","def start_game(self, level: Level):\n # Initialize game state and begin\n self.game_state = Gamestate(level, len(self.player_list), 1, self.init_levels)\n for player in self.player_list:\n spawn_tile = self.game_state.get_random_spawn_tile()\n self.game_state.add_character(player.entity, spawn_tile)\n # First level has one zombie and no ghosts\n first_zombie = EnemyZombie(\"zombie\", \"zombie\")\n self.add_enemies(first_zombie)\n for enemy in self.enemy_list:\n enemy_spawn = self.game_state.get_random_spawn_tile()\n self.game_state.add_adversary(enemy.entity, enemy_spawn)","def spawn_players(self) -> None:\n #Create the player\n self.player1 = Player(self.sensitivity, self.screen_width, self.screen_height, self.screen_width//(3/2), self.screen_height-50, self.player_lives, self.fps, self.player1_bullet, Direction.UP, self.debug)\n\n #Create the AI\n self.player2 = AIPlayer(self.sensitivity, self.screen_width, self.screen_height, self.screen_width//3, self.screen_height-50, self.player_lives, self.fps, self.player2_bullet, Direction.UP, 1, True, self.debug)","def action_normal(self):\n obs = self.observation\n shoot = False\n eb = self.__class__.enemy_base\n \n ammopacks = filter(lambda x: x[2] == \"Ammo\", obs.objects)\n if ammopacks:\n self.updateAllAmmoSpots(ammopacks)\n # Walk to ammo\n if obs.ammo < SUFFICIENT_AMMO:\n self.goal = self.getClosestLocation(ammopacks)\n self.motivation = MOTIVATION_AMMO\n self.debugMsg(\"*> Recharge (%d,%d)\" % (self.goal[0],self.goal[1]))\n \n '''if (obs.ammo > 0 and obs.foes):\n self.goal = self.getClosestLocation(obs.foes)\n self.debugMsg(\"*> Go to enemy (%d,%d)\" % self.goal)\n # If the enemy is within range, shoot.\n if(point_dist(self.goal, obs.loc) < self.settings.max_range\n and not line_intersects_grid(obs.loc, self.goal, self.grid, self.settings.tilesize)):\n self.debugMsg(\"*> Shoot (%d,%d)\" % self.goal)\n #if self.goal not in obs.friends:\n self.motivation = MOTIVATION_SHOOT_TARGET\n shoot = True'''\n \n # Attack strategy 1\n #########################\n # 1) Shoot live enemies #\n #########################\n # Aim at the closest enemy outside the enemy base\n if obs.ammo > 0 and obs.foes:\n living = filter(lambda x: point_dist(x[0:2], eb) > ENEMY_BASE_RANGE, obs.foes)\n self.debugMsg(\"Living: %s\" % (living,))\n if living:\n self.debugMsg(1)\n self.goal = min(living, key=lambda x: point_dist(obs.loc, x[0:2]))[0:2]\n self.motivation = MOTIVATION_SHOOT_TARGET\n self.debugMsg(2)\n # Check if enemy in fire range\n if (\n point_dist(self.goal, obs.loc) < self.settings.max_range and\n not line_intersects_grid(\n obs.loc, \n self.goal, \n self.grid, \n self.settings.tilesize\n )\n ):\n self.debugMsg(3)\n self.debugMsg(\"*> Shoot (%d,%d)\" % self.goal)\n #return self.getActionTriple(True,None,0) ###?? SHOULD WE STOP MOVING WHEN WE SHOOT?\n return self.getActionTriple(True)\n else:\n self.debugMsg(4)\n return self.getActionTriple()\n self.debugMsg(5)\n \n # Walk to an enemy CP\n if self.goal is None and len(self.friendlyCPs) < 2:\n self.goal = self.getClosestLocation(self.getQuietEnemyCPs())\n if self.goal:\n self.debugMsg(\"Crowded location: %d\" % self.getCrowdedValue(self.goal))\n self.motivation = MOTIVATION_CAPTURE_CP\n self.debugMsg(\"*> Capture (%d,%d)\" % (self.goal[0],self.goal[1]))\n \n '''# If you can't think of anything to do\n # at least walk to a friendly control point\n if self.goal is None:\n self.goal = self.getClosestLocation(self.getQuietRestlessFriendlyCPs())\n if self.goal:\n self.motivation = MOTIVATION_GUARD_CP\n self.debugMsg(\"*> Guard (%d,%d)\" % (self.goal[0],self.goal[1]))'''\n \n if self.goal is None:\n self.goal = max(\n self.__class__.ammoSpots,\n key=lambda x: point_dist(x, obs.loc),\n )\n self.debugMsg(\"Going to ammospot far away (%d, %d)\" % (self.goal[0],self.goal[1]))\n self.motivation = MOTIVATION_STAY_PUT\n \n\n if self.goal:\n return self.getActionTriple(shoot)\n else:\n return self.getActionTriple(shoot)","def Start(self):\n\n # Keep updating until all agents have completed their waypoints\n all_finished = False\n while not all_finished:\n all_finished = True\n self.player_client.read()\n for agent in self.agents:\n all_finished = agent.update() and all_finished","def run_ai(self):\n state = self.brainstate\n me = self.owner\n if not self.owner.alive:\n return\n self._acquire_target()\n if 'target' in state:\n self._move_towards_target()\n else:\n # No target, wander around\n if random.random() > 0.3:\n possible_directions = [i for i in\n ([-1, -1], [-1, 0], [-1, 1], [0, -1],\n [0, 1], [1, -1], [1, 0], [1, 1])\n if afr.map.map.tile_is_traversable(\n me.x + i[0],\n me.y + i[1]\n )\n ]\n logging.debug(\"possible directions: %s\", possible_directions)\n movement = random.choice(possible_directions)\n me.x += movement[0]\n me.y += movement[1]","def setup_npcs(self):\n super().setup_npcs()\n npc_data = [\n [Carrots, \"images/items/carrots.png\", 1, 220, 640],\n [Mushroom, \"images/items/mushroom.png\", 1, 1028, 264],\n [Grandma, \"images/people/grandma.png\", 3, 400, 400],\n ]\n for sprite_class, image, scale, x, y in npc_data:\n sprite = sprite_class(resolve_resource_path(image), scale)\n sprite.center_x = x\n sprite.center_y = y\n self.npc_list.append(sprite)\n\n grandma = self.npc_list[-1]\n grandma.strategy = RandomWalk(0.05)","def start_threaded_attack(\n self, attack, wait=False, attributes=None):\n attack_thread = threading.Thread(\n target=attack,\n args=([]))\n attack_thread.start()\n if wait:\n attack_thread.join()","def CombatAttack(self):\n self.attacker.Attack(target=self.defender)","def new_skill_interaction(self, skill):\n self.skill_interact[skill] = True","def install_default_skills(speak=True):\n if exists(MSM_BIN):\n p = subprocess.Popen(MSM_BIN + \" default\", stderr=subprocess.STDOUT,\n stdout=subprocess.PIPE, shell=True)\n (output, err) = p.communicate()\n res = p.returncode\n if res == 0 and speak:\n # ws.emit(Message(\"speak\", {\n # 'utterance': mycroft.dialog.get(\"skills updated\")}))\n pass\n elif not connected():\n LOG.error('msm failed, network connection is not available')\n ws.emit(Message(\"speak\", {\n 'utterance': mycroft.dialog.get(\"no network connection\")}))\n elif res != 0:\n LOG.error('msm failed with error {}: {}'.format(res, output))\n ws.emit(Message(\"speak\", {\n 'utterance': mycroft.dialog.get(\n \"sorry I couldn't install default skills\")}))\n\n else:\n LOG.error(\"Unable to invoke Mycroft Skill Manager: \" + MSM_BIN)","def cmd_start(update, context):\n\n context.bot.send_message(\n chat_id=update.effective_chat.id,\n text=f\"Halo salam kenal! Aku Bot dari Planet Ban {emo_heart_eyes}\")","async def start(self, context):\n try: \n if context.author.is_mod:\n self.tournament.start = True\n self.tournament.clear_file()\n await context.send('Arrancando el torneo manda !yo y tu nombre')\n except Exception as error:\n print(error)","def create(self):\n\n self._calculate_hp()\n self.race.alterAbilities()\n self.race.racialAbilities()","def all():\n lab = test_loading()\n\n for _ in range(1):\n print('🦅🐀🐙')\n\n test_spawn(lab)\n\n pc = test_spawn_player(lab)\n\n while True:\n pc.store_move(PlayerMove(random.choice(['walk left', 'walk up', 'walk down', 'walk right'])))\n test_turn_ai_and_players(lab)\n if input() == '0':\n break","async def start(self, ctx):\n if ctx.guild is None:\n await ctx.reply(\"This command can only be used in a server, not in DMs.\")\n raise commands.CommandError(\"Invoker not in a guild.\")\n\n if ctx.voice_client is None or ctx.voice_client.channel is None:\n await ctx.reply(f\"I am not in a voice channel, invite me first with `{self.bot_config['prefix']}join`.\")\n raise commands.CommandError(\"Bot not connected to a voice channel.\")\n\n if ctx.author.voice is None or ctx.author.voice.channel is None:\n await ctx.reply(\"You need to be in a voice channel to use this command.\")\n raise commands.CommandError(\"Invoker not connected to a voice channel.\")\n\n if ctx.voice_client is not None and ctx.author.voice.channel != ctx.voice_client.channel:\n await ctx.reply(\"You need to be in the same voice channel as the bot to use this command.\")\n raise commands.CommandError(\"Invoker not in same voice channel as bot.\")\n\n if ctx.voice_client is not None and ctx.voice_client.channel is not None:\n controller = SpotifyController.get_instance(ctx.voice_client.channel.id)\n if controller is None:\n await ctx.reply(f\"I'm not playing anything at the moment.\")\n raise commands.CommandError(\"Bot not connected to active spotify session.\")\n else:\n await ctx.reply(f\"I am not in a voice channel, invite me first with `{self.bot_config['prefix']}join`.\")\n raise commands.CommandError(\"Bot not connected to a voice channel.\")\n\n queue, is_playing, current_index, current_progress_ms = controller.get_queue()\n\n if current_index is not None:\n await ctx.reply(f\"I'm already playing the room playlist!\")\n raise commands.CommandError(\"Bot not connected to a voice channel.\")\n\n controller.start_playback()\n await ctx.message.add_reaction(\"👍\")","def onSpawn(self):\n self.spawned = True\n self._interactor.initialiseDevices()","def start(update, context):\n context.bot.send_message(\n chat_id=update.effective_chat.id, text=\"Hi human\")","def start(msg: telebot.types.Message):\n logger.info(f'New /start command from id: {msg.from_user.id}.')\n\n bot.send_message(\n msg.from_user.id,\n 'Hello, welcome to TicTacDrop!',\n reply_markup=buttons.get_play_markup()\n )\n\n utils.save_user(msg.from_user)","def explode(self):\n\n self.hit = True\n self.max_speed = 135\n self.destruction_sound.play()\n self.death_animation_timer.start()\n self.image = DESTRO_ENEMY","def fight(self, combat_item):\r\n print(self.name + \" doesn't want to fight with you\")\r\n return True","def resetSkills(self):\r\n \"\"\" Reset the default attributes \"\"\"\r\n self.player['level'] = 1\r\n self.player['xp'] = 0\r\n self.player['credits'] = int(startCredits)\r\n self.player['popup'] = int(popupStatus)\r\n self.player['name'] = self.player.name\r\n self.player['lastconnected'] = int(time.time())\r\n\r\n \r\n \"\"\" Iterate through the skills list then set each skill to 0 \"\"\"\r\n for skill in skills:\r\n self.player[skill.name] = 0\r\n\r\n \"\"\" Slay the player \"\"\"\r\n es.server.queuecmd(\"damage %s %s\" % (self.userid, es.getplayerprop(self.userid, \"CBasePlayer.m_iHealth\")))\r\n \r\n \"\"\" Notify the user \"\"\"\r\n tell(self.userid, 'info deleted')","def run_game(self) -> None:\n decision = 0\n if self._initial:\n self._initial = False\n while decision != 1:\n try:\n display_no_combat_init(self.hero)\n decision = get_user_input([1, 2, -1])\n if decision == -1:\n self._quit()\n elif decision == 2:\n self._show_bag()\n else:\n break\n except KeyboardInterrupt:\n print(\"[!] If you want to quit, use the provided user interface\")\n\n while not self.hero.is_dead:\n try:\n self._load_map()\n except KeyboardInterrupt:\n print(\"[!] If you want to quit, use the provided user interface\")","def start(self, world):\n self.sense(world)","def skills_manager(message):\n global skills_manager_timer\n\n if connected():\n if skills_manager_timer is None:\n pass\n # Install default skills and look for updates via Github\n LOG.debug(\"==== Invoking Mycroft Skill Manager: \" + MSM_BIN)\n install_default_skills(False)\n\n # Perform check again once and hour\n skills_manager_timer = Timer(3600, _skills_manager_dispatch)\n skills_manager_timer.daemon = True\n skills_manager_timer.start()","def on_attack(self, target, friendly):\n # Get buff from Dread Admiral Eliza\n if self.race == 'pirate' or self.race == 'all':\n eliza_buff_atk, eliza_buff_dfs = friendly.friendly_eliza_buff\n for each in friendly.minions:\n each.get_buff(eliza_buff_atk, eliza_buff_dfs)\n\n # If divine shield, not getting hurt\n if not self.divine_shield:\n self.hurt = True\n if not target.divine_shield:\n target.hurt = True","def play(self):\n print(f\"Welcome, to the Adventure games.\\n\"\n \"May the randomly generated numbers be ever in your favour.\\n\"\n f\"\\n{adventure.current_room.description}\")\n\n # Prompt the user for commands until they've won the game.\n while not self.won():\n # This method for FORCED only works on Small and Tiny,\n # it works until the end of CrowtherRooms, when FORCED is not the\n # only possible direction for a room. I am working on fixing this,\n # and I think I'm very close, but I won't be able to fix it in time.\n # I can send that version it by e-mail though, if you want!\n\n # For now, this handles the FORCED movements\n if len(adventure.current_room.connection) == 1:\n adventure.move(\"FORCED\")\n if adventure.current_room.id in self.idlist:\n print(adventure.current_room.name)\n else:\n print(adventure.current_room.description)\n if len(adventure.current_room.inventory.itemlist) > 0:\n for item in adventure.current_room.inventory.itemlist:\n print(f\"{item.name}: {item.description}\")\n\n # Get a new direction from the user\n command = input(\"> \")\n command = command.upper()\n movements = [\n \"NORTH\", \"SOUTH\", \"EAST\", \"WEST\", \"UP\", \"DOWN\",\n \"OUT\", \"IN\", \"XYZZY\", \"WAVE\", \"WATER\", \"JUMP\"]\n abbreviations = {\n \"Q\": \"QUIT\", \"L\": \"LOOK\", \"I\": \"INVENTORY\", \"N\": \"NORTH\",\n \"S\": \"SOUTH\", \"E\": \"EAST\", \"W\": \"WEST\", \"U\": \"UP\", \"D\": \"DOWN\"}\n if command in abbreviations and len(command) == 1:\n command = abbreviations[command]\n\n # Check if the command is a valid movement\n if command in movements and self.current_room.isvalid(command):\n\n # Print appropriate room name/description after moving\n self.idlist.append(adventure.current_room.id)\n adventure.move(command)\n if adventure.current_room.id in self.idlist:\n print(adventure.current_room.name)\n else:\n print(adventure.current_room.description)\n\n # Print current room's inventory\n for item in adventure.current_room.inventory.itemlist:\n print(f\"{item.name}: {item.description}\")\n\n # Handle any additional commands\n elif command == \"HELP\":\n print(f\"You can move by typing directions such as EAST/WEST/IN/OUT\\n\"\n \"QUIT quits the game.\\n\"\n \"HELP prints instructions for the game.\\n\"\n \"INVENTORY lists the item in your inventory.\\n\"\n \"LOOK lists the complete description of the room and its contents.\\n\"\n \"TAKE <item> take item from the room.\\n\"\n \"DROP <item> drop item from your inventory.\")\n elif command == \"QUIT\":\n print(\"Thanks for playing!\")\n exit(0)\n elif command == \"LOOK\":\n print(adventure.current_room.description)\n if len(adventure.current_room.inventory.itemlist) > 0:\n for item in adventure.current_room.inventory.itemlist:\n print(f\"{item.name}: {item.description}\")\n elif len(command.split()) > 1:\n if command.split()[0] == \"TAKE\":\n adventure.take(command.split()[1])\n elif command.split()[0] == \"DROP\":\n adventure.drop(command.split()[1])\n elif command == \"INVENTORY\":\n if len(self.player.itemlist) > 0:\n for item in self.player.itemlist:\n print(f\"{item.name}: {item.description}\")\n else:\n print(\"Your inventory is empty.\")\n else:\n print(\"Invalid command.\")\n exit(0)","def start(self):\n for trial in self._trials:\n self._run(trial)","def at_start(self):\n if not self.db.started:\n self.player.start()\n self.db.started = True","def setup(self):\n\n # Sprite lists\n self.all_sprite_list = arcade.SpriteList()\n self.player_list = arcade.SpriteList()\n self.coin_list = arcade.SpriteList()\n self.deathclaw_list = arcade.SpriteList()\n # Score\n self.score = 0\n\n # Set up the player\n # Character image from https://www.pngkit.com/\n self.player_sprite = arcade.Sprite(\"Vault_Boy.png\", SPRITE_SCALING_PLAYER)\n self.player_sprite.center_x = 50\n self.player_sprite.center_y = 50\n self.player_list.append(self.player_sprite)\n\n # Create the ENEMY\n for i in range(DEATHCLAW_COUNT):\n\n # Create the ENEMY instance\n # ENEMY image from https://fallout.fandom.com/\n deathclaw = Deathclaw(\"Deathclaw.png\", SPRITE_SCALING_DEATHCLAW)\n\n # Position the coin\n deathclaw.center_x = random.randrange(SCREEN_WIDTH)\n deathclaw.center_y = random.randrange(SCREEN_HEIGHT)\n\n # Add the coin to the lists\n self.deathclaw_list.append(deathclaw)\n\n for i in range(COIN_COUNT):\n\n # Create the Nuka Cola instance\n # Nuka Cola image fromh https://www.cleanpng.com/free/nuka-cola.html\n coin = Coin(\"Nuka_Kola.png\", SPRITE_SCALING_COIN)\n\n # Position the coin\n coin.center_x = random.randrange(SCREEN_WIDTH)\n coin.center_y = random.randrange(SCREEN_HEIGHT)\n\n # Add the coin to the lists\n self.coin_list.append(coin)","def startRandom(session):\n rarity = Rarities.getRandomRarity()\n # Select a random quest from the database based on the random % rarity\n quest = None\n while True:\n # Rpeat this process until you get a not already active/valid/enabled quest\n quest = session.query(Quest).filter(Quest.rarity == rarity).order_by(func.random()).first()\n #TODO: isQuestActive()\n \n if quest.is_active == True and quest.isActive(session) == False:\n break\n\n activequest = QuestActive(time_stop = datetime.datetime.now() + datetime.timedelta(days = quest.interval_days),\n quest = quest\n )\n print(\"Started random quest %s\" % (quest.id))\n session.add(activequest)\n session.commit()\n return quest.id","def attack(self):\n if not self.attack_mode and not self.damage_mode and not self.death_mode:\n self.attack_group = choice(self.attack_groups)\n self.attack_mode = True\n self.cut_frame_update = 0","def attack(self, enemy_squads_list, army_name):\n enemy = SQUAD_STRATEGIES[self.strategy](enemy_squads_list)\n attacker_success = self.calc_squad_attack_success()\n attacker_damage = self.calc_squad_damage()\n\n enemy_success = enemy.calc_squad_attack_success()\n print(f'{army_name} attack_success = {attacker_success} - enemy attack_success = {enemy_success}')\n if attacker_success <= enemy_success:\n return {\n \"success\": 'lost',\n \"damage\": 0,\n }\n enemy.take_damage(attacker_damage)\n self.update_soldier_experience()\n self.update_units_time_last_attack()\n print(f'{army_name} caused damage = {attacker_damage}, enemy squad health = {enemy.squad_health()}')\n return {\n \"success\": 'win',\n \"damage\": attacker_damage,\n }","def plant_food(self):\n self.phase.set(0)\n #self.broadcast_phase()\n self.players[self.first_player].take_turn()","def activate(self):\n self.robot = self.behavior_system.robot\n self.cozmo = self.robot.cozmo\n\n # Play the animation\n try:\n self.angry_anim = self.cozmo.play_anim_trigger(cozmosdk.anim.Triggers.DriveStartAngry)\n self.angry_anim.on_completed(lambda evt, **kwargs: self._angry_anim_completed(evt))\n except:\n pass","def level_time_simulate(start_levels, attack_style, attack_bonus, strength_bonus):\n ticks_per_attack = 4 # Scimitar attack speed\n enemy_health = 60 # Sand crab health\n\n max_hit, accuracy = get_max_hit_and_accuracy(\n start_levels, attack_style, attack_bonus, strength_bonus)\n \n if attack_style == Attack_Style.ATTACK:\n start_exp = osrs.experience[start_levels.attack]\n end_exp = osrs.experience[start_levels.attack+1]\n elif attack_style == Attack_Style.STRENGTH:\n start_exp = osrs.experience[start_levels.strength]\n end_exp = osrs.experience[start_levels.strength+1]\n \n experience = end_exp - start_exp\n avg_ticks = combat_simulator.ticks_until_exp(max_hit, accuracy,\n ticks_per_attack, enemy_health, experience,\n osrs.BASE_EXP_PER_DAMAGE, ITERATIONS)\n return avg_ticks","def start(self, agents):\n self.current_state = self.startState()\n self.agents = agents\n for i,agent in enumerate(self.agents):\n agent.setPlayerId(i)\n\n return self.current_state","def move_me_on_spawn(self):\r\n\t\tif self.points_to_go:\r\n\t\t\tself.start_pos = self.points_to_go[0]\r\n\t\t\tfor point in self.points_to_go[1:]:\r\n\t\t\t\tfor i in range(len(self.points_to_go[1:])):\r\n\t\t\t\t\tself.goal_pos = self.points_to_go[i]\r\n\t\t\t\t\t\r\n\t\t\t\t\tself.move_me()\r\n\t\t\t\t\t#self.start_pos = \r\n\t\t\t\t\t#print(self.goal_pos)\r\n\t\t\t\t\t#if self.move_me():\r\n\t\t\t\t\t#\ti += 1\r\n\t\t\t\t\t#\tprint('switch')\r","def do_eat(self, args):\n\n name = pick(\"Agent\", self.model.get_agent_names())\n if name is not None:\n food = int(input(\"Food to eat?\"))\n agent = self.model.get_agent(name)\n agent.eat(food)","def start():\n commands = {\"new tournament\": Controller.new_tournament,\n \"new round\": Controller.new_round,\n \"new player\": Controller.new_player,\n\n \"set round\": Controller.set_round,\n \"set player\": Controller.set_player,\n\n \"get players -all -alpha\": Controller.get_all_players_alpha,\n \"get players -all -rank\": Controller.get_all_players_rank,\n \"get players -alpha\": Controller.get_players_alpha,\n \"get players -rank\": Controller.get_players_rank,\n\n \"get tournament -all\": Controller.get_all_tournaments,\n \"get tournament\": Controller.get_tournament,\n\n \"get round -all\": Controller.get_all_rounds,\n \"get round\": Controller.get_round,\n\n \"get match -all\": Controller.get_all_matches,\n \"get match\": Controller.get_match,\n\n \"load\": Controller.load,\n\n \"exit\": Controller.close_app\n }\n\n # At the beginning of the program, load all data from a data_base.\n Controller.load()\n print(\"Need help? Type 'commands' to see all commands and there purposes.\")\n\n while True:\n instruction = str(input(\"ChessManager >>> \"))\n try:\n commands[instruction]()\n except KeyError:\n print(\"Wrong Command.\")","def on_pre_enter(self):\n Logger.info('Application: Changed to the Combat screen.')\n Logger.info(\n 'Application: '\n 'The ship chosen for combat is the '\n '\"{}\" type.'.format(self.player.type)\n )\n Logger.info('Application: Stats: {}.'.format(self.player.stats))\n self.start_soundtrack()\n\n # Set the event interval of every frame\n self.updater = Clock.schedule_interval(self.update, 1.0/60.0)\n\n # Populate round/level objects and collidable lists\n self.collidables = []\n self.spaceships = []\n\n # Sets the combat stage/hostiles based on players level\n self.set_level_hostiles()\n\n\n for asteroid in self.asteroids:\n self.collidables.append(asteroid)\n for ship in self.spaceships:\n self.collidables.append(ship)","def actions_turn(positions, player1, player2, creatures):\n\n attacking = []\n moving = []\n\n # Split the orders within attacks and movements\n for character in positions:\n if character in creatures:\n if positions[character]['order'] == 'attack':\n attacking += character\n else:\n moving += character\n elif character in player1:\n if positions[character]['order'] == 'attack':\n attacking += character\n else:\n moving += character\n\n else:\n if positions[character]['order'] == 'attack':\n attacking += character\n else:\n moving += character\n\n # Execute the attacks\n for character in attacking:\n # First attacking : the creatures\n if character in creatures:\n hero_name = character\n name_attack = positions[character]['name_attack']\n attack_coord = positions[character]['where']\n attack(positions, hero_name, name_attack, (0, 0), attack_coord, player1, player2, creatures)\n # Then the heroes of the first player\n elif character in player1:\n hero_name = character\n name_attack = positions[character]['name_attack']\n attack_coord = positions[character]['where']\n attack(positions, hero_name, name_attack, (0, 0), attack_coord, player1, player2, creatures)\n # Finally the ones of the second player\n else:\n hero_name = character\n name_attack = positions[character]['name_attack']\n attack_coord = positions[character]['where']\n attack(positions, hero_name, name_attack, (0, 0), attack_coord, player1, player2, creatures)\n\n for character in moving:\n print(character, moving)\n # First moving : the creatures\n if character in creatures:\n hero_name = character\n movement_coord = positions[character]['where']\n move(hero_name, positions, movement_coord)\n\n # Then the heroes of the first player\n elif character in player1:\n hero_name = character\n movement_coord = positions[character]['where']\n move(hero_name, positions, movement_coord)\n\n # Finally the ones of the second player\n else:\n hero_name = character\n movement_coord = positions[character]['where']\n move(hero_name, positions, movement_coord)\n\n return player1, player2, positions, creatures","async def play_axe(game_state) -> None:\n if len(game_state.active_player.zombies) > 0:\n play_weapon(game_state, Supply.AXE)\n else:\n game_state.active_player.print(f'You cannot play {Supply.AXE.value} for nothing!')","def execute_for_command(self, skill_input: SkillInput, services: AssistantServicesBase):\n voice = skill_input.adjective.lower()\n if voice in (\"female\", \"male\"):\n services.settings_service.voice = voice\n services.settings_service.save_settings()\n services.user_interaction_service.speak('Okay, I will use a %s voice from now on.' % (voice), True)\n else:\n services.user_interaction_service.speak('I don\\'t understand what voice you want')","def _do_start(self, chat_id, user_id, args, update):\n \n self.tclient.send_message('Hallo! Ich bin ein Bot, um dir zu helfen, dir deine Nasensprüche zu merken!', chat_id)","def loadallskills(self):\r\n for skill in os.listdir( os.path.join( es.getAddonPath( info.basename ), \"skills\" )):\r\n es.load(\"%s/skills/%s\" % (info.basename, skill))","def attack_target_mob(self, text_input, dam_mod=None, success_verb=None, fail_verb=None, outcome=f\"\"):\n # TODO: Time to kill bats and goblins is good (2-3 rounds, max end is 5-6 with bad luck).\n # TODO: They hit too frequently/do too much damage without being able to heal or mitigate damage.\n # TODO: Add in heal ability/potions (how to make it useful, but not too easy? - extended CD?)\n # TODO: Increase monster EXP to reduce levelling rate (too slow ATM).\n # TODO: Damage mitigation via armor (both reduce to-hit and reduce damage amount?)\n entry = f\"\"\n target, search_term = search(self, text_input, \"room.mobs\")\n Report = namedtuple(\"Report\", (\"success\", \"target\"))\n if target:\n # Just going to have the player attack the first mob of that type in the room for now. I'll figure out how\n # I want to do selection later.\n mob = target[0]\n attack = attack_action(self, mob, dam_mod)\n if attack.hit:\n if success_verb:\n attack_verb = f\"{success_verb} the {mob}\"\n else:\n attack_verb = (\n f\"{self.equipped_weapon.main_hand.success_verb} the {mob} with your \"\n f\"{self.equipped_weapon.main_hand.name}\"\n )\n if attack.hit_type == \"hit\":\n entry += f\"You {attack_verb}\"\n elif attack.hit_type == \"crit\":\n entry += f\"You savagely {attack_verb}\"\n entry += f\" for {attack.damage} damage\"\n if mob.current_hp <= 0:\n self.xp += mob.xp\n entry += (\n f\", killing it!\\n\"\n f\"You gain {mob.xp} xp.\"\n )\n mob.kill_monster()\n else:\n entry += f\"{outcome}.\\n\"\n else:\n if fail_verb:\n attack_verb = f\"{fail_verb} the {mob}\"\n else:\n attack_verb = (\n f\"{self.equipped_weapon.main_hand.fail_verb} the {mob} with your \"\n f\"{self.equipped_weapon.main_hand.name}\"\n )\n entry += f\"You {attack_verb} but\"\n if attack.hit_type == \"miss\":\n entry += (\n f\" missed.\"\n )\n if attack.hit_type == \"dodge\":\n entry += (\n f\" the {mob} dodged out of the way.\"\n )\n self.add_messages(entry)\n self.journal.add_entry(f\"(Round {self.turn_counter}): \" + entry)\n return Report(attack.hit, mob)\n else:\n self.add_messages(f\"You do not see one of those.\")\n return Report(False, None)","def bcp_game_start(self, **kargs):\n self.bcp_player_add(number=1)\n self.bcp_player_turn_start(player=1)\n self.events.post('game_started', **kargs)","def fireMyWeapons(self):\n for myWeapon in self.readyWeapons:\n myWeapon.fire()\n\n self.readyWeapons = []","def start_stage2(ai_settings,boss,ship):\n\t\tpygame.mixer.music.load('sounds/lvl2.mp3')\n\t\tpygame.mixer.music.set_volume(1.5)\n\t\tpygame.mixer.music.play()\n\t\tai_settings.ui_text_color = (255, 0, 0)\n\t\tai_settings.bg_color = (255, 255, 255)\n\t\tai_settings.boss_speed_factor = 12\n\t\tai_settings.boss_bullet_speed_factorD = 15\n\t\tai_settings.boss_bullet_speed_factor = 15\n\t\tai_settings.boss_bullet_color = (0, 0, 0)\n\t\tai_settings.boss_health = 5000\n\t\tboss.image = pygame.image.load('images/boss2.bmp')\n\t\tship.second_stage = True\n\t\tai_settings.boss_direction *= -1","async def giveaway_start(self, ctx):\n\n game = await self._get_random_game()\n if game is None:\n await ctx.reply(\"No more games!\")\n return\n\n giveaway_id = await self._create_giveaway(game['game_id'])\n giveaway_data = await self._get_giveaway(giveaway_id)\n\n self._tasks[giveaway_id] = self.bot.loop.create_task(\n self.giveaway_task(\n ctx,\n giveaway_data=giveaway_data,\n timeout=None,\n )\n )","def squad_attacks(self, attacker, defender):\n\n for unit in attacker.units:\n if(len(defender.units) != 0):\n if(unit.hit):\n enemy = R.choice(defender.units)\n enemy.damage_inflicte(unit.beat(enemy))\n else:\n return","def onStart(self, agent):\n\n pass"],"string":"[\n \"def StartCombat(self):\\n\\n print(\\\"------------------------------------\\\")\\n self.fighter1.PrintInfo()\\n self.fighter2.PrintInfo()\\n print(\\\"------------------------------------\\\")\\n self.combatInProgress = True\\n while self.combatInProgress and self.currentTurn < self.maxTurns:\\n print(\\\"Turn {}:\\\".format(self.currentTurn))\\n self.CombatAttack()\\n if self.EndTurn():\\n print(\\\"------------------------------------\\\")\\n break\\n print(\\\"------------------------------------\\\")\\n time.sleep(3)\",\n \"def run_combat(self, monster1, monster2):\\n\\n ce = combat_engine.CombatEngine(monster1, monster2, log_ref=self)\\n ce.run_combat()\",\n \"def begin_encounter(self):\\r\\n\\r\\n #introduce NPCs - run all introduce methods, unless the NPCs have the same name\\r\\n for i in range(len(self.npc_names)):\\r\\n for _npc in self.npc_list:\\r\\n if _npc.name == self.npc_names[i]:\\r\\n _npc.introduce(self.npc_quantities[i], self.location)\\r\\n break\\r\\n\\r\\n #list visible enemies\\r\\n self.display_npcs()\\r\\n\\r\\n #check close proximity - if hostile enemy within 10 ft, don't go to interact menu\\r\\n hostile_close_proximity = False\\r\\n \\r\\n for m in range(len(self.npc_distances)):\\r\\n if self.npc_distances[m] < 10:\\r\\n if self.npc_list[m].hostility == utils.HostilityLevel.HOSTILE:\\r\\n hostile_close_proximity = True\\r\\n multiple = self.npc_quantities[self.npc_names.index(self.npc_list[m].name)] > 1\\r\\n self.npc_list[m].alert_close_proximity(multiple)\\r\\n break\\r\\n\\r\\n interaction_result = NextState\\r\\n \\r\\n if hostile_close_proximity:\\r\\n #start combat\\r\\n interaction_result = NextState.COMBAT\\r\\n else:\\r\\n #run interaction choice menu - interactions may return flags that spawn social/combat encounters\\r\\n print(\\\"Select NPC to interact with:\\\")\\r\\n for l in range(len(self.npc_list)):\\r\\n print(str(l + 1) + \\\". \\\" + self.npc_list[l].name + \\\" (Distance: \\\" + str(self.npc_distances[l]) + \\\"ft.)\\\")\\r\\n \\r\\n choice = 0\\r\\n while choice < 1 or choice > len(self.npc_names) + 1:\\r\\n try:\\r\\n choice = int(input(\\\"Make selection: \\\"))\\r\\n except:\\r\\n print(\\\"Enter an integer between 1 and \\\" + str(len(self.npc_names)))\\r\\n \\r\\n interaction_result = self.npc_list[choice - 1].interact(self, choice - 1, self.main_player)\\r\\n\\r\\n #spawn social/combat encounter\\r\\n #if combat, pass npc list to generate turn order\\r\\n if interaction_result.name == \\\"COMBAT\\\":\\r\\n #spawn combat encounter\\r\\n print(\\\"Starting combat\\\")\\r\\n new_combat = combat.CombatEncounter(self.main_player, self.npc_list, self.npc_distances, self.npc_quantities)\\r\\n elif interaction_result.name == \\\"SOCIAL\\\":\\r\\n #spawn social encounter\\r\\n print(\\\"Starting social encounter\\\")\\r\\n elif interaction_result.name == \\\"FINISHED\\\":\\r\\n #present next choices, award loot from area\\r\\n #allow player to interact with any remaining/new NPCs\\r\\n print(\\\"Encounter finished\\\")\\r\\n elif interaction_result.name == \\\"DEATH\\\":\\r\\n #kill the player and end the game\\r\\n print(\\\"Player dead\\\")\",\n \"def start(self):\\n self.startAngMovementALl()\\n self.startMovementAll()\",\n \"def _starting_up():\\n global ws, skill_reload_thread, event_scheduler\\n\\n ws.on('intent_failure', FallbackSkill.make_intent_failure_handler(ws))\\n\\n # Create skill_manager listener and invoke the first time\\n ws.on('skill_manager', skills_manager)\\n ws.on('mycroft.internet.connected', install_default_skills)\\n ws.emit(Message('skill_manager', {}))\\n\\n # Create the Intent manager, which converts utterances to intents\\n # This is the heart of the voice invoked skill system\\n\\n PadatiousService(ws)\\n IntentService(ws)\\n event_scheduler = EventScheduler(ws)\\n # Create a thread that monitors the loaded skills, looking for updates\\n skill_reload_thread = WatchSkills()\\n skill_reload_thread.daemon = True\\n skill_reload_thread.start()\\n\\n # Wait until skills have been loaded once before starting to check\\n # network connection\\n skill_reload_thread.wait_loaded_priority()\\n check_connection()\",\n \"def use_skill(self, g, i, x, y):\\n # @ param g a reference to the game engine\\n # @ param i the index of the skill (basically what skill)\\n # @ param x the x target coordinate in game pixels\\n # @ param y the y target coordinate in game pixels\\n if self.attackTimer < self.attackDelay:\\n print(\\\"attack on CD\\\")\\n return\\n \\n if self.skill[i].skillAttr == 0:\\n g.fire_skill_sound.play()\\n elif self.skill[i].skillAttr == 1:\\n g.ice_skill_sound.play()\\n elif self.skill[i].skillAttr == 2:\\n g.lightning_skill_sound.play()\\n elif self.skill[i].skillAttr == 3:\\n g.poison_skill_sound.play()\\n \\n \\n if self.skill[i].skillKey == 0: #Aura\\n #turn the aura on/off\\n if self.skill[i].active == False:\\n #print(\\\"aura on\\\")\\n self.skill[i].active = True\\n else:\\n self.skill[i].active = False\\n #print(\\\"aura off\\\")\\n \\n elif self.skill[i].skillKey == 1: #Missile\\n if self.mana[0] > self.skill[i].skillCost:\\n self.mana[0] -= self.skill[i].skillCost\\n self.attackTimer = 0\\n target = Target(x, y)\\n center_x = self.rect.x + (self.rect.width / 2)\\n center_y = self.rect.y + (self.rect.height / 2)\\n #bullet types: fire 5, ice 6, lightning 7\\n #skill types: fire 0, ice 1, lightning 2\\n g.bullets.append(self.bulletFactory.createBullet(g, self.skill[i].skillAttr + 5, 0, self.attack, 1024, target, center_x, center_y))\\n #print(\\\"missile\\\")\\n\\n elif self.skill[i].skillKey == 2: #Breath\\n #for each creep in the AoE cone, do damage.\\n if self.mana[0] > self.skill[i].skillCost:\\n self.mana[0] -= self.skill[i].skillCost\\n self.attackTimer = 0\\n #get low and high angle (-45 degrees and +45 degrees from player -> point angle)\\n lowAngle = math.atan2(y - self.rect.centery, x - self.rect.centerx) - 3.1415 / 2.0\\n highAngle = math.atan2(y - self.rect.centery, x - self.rect.centerx) + 3.1415 / 2.0\\n for creep in g.creeps:\\n #get angle to creep\\n creepAngle = math.atan2(creep.rect.centery - self.rect.centery, creep.rect.centerx - self.rect.centerx)\\n \\n #if angle to the creep is between the two angles\\n if creepAngle > lowAngle and creepAngle < highAngle:\\n #and the distance to the creep is below the skill's range\\n if ( (creep.rect.centerx - self.rect.centerx) ** 2 + (creep.rect.centery - self.rect.centery) ** 2 ) ** 0.5 < 4 * 24:\\n creep.take_damage( self.attack )\\n #print(\\\"breath\\\")\\n #apply debuffs, based on type\\n if self.skill[i].skillAttr == 0: #fire\\n creep.applyBurning()\\n elif self.skill[i].skillAttr == 1: #frost\\n creep.applyChilled()\\n elif self.skill[i].skillAttr == 2: #lightning\\n creep.applyShocked()\",\n \"def startBattle(self):\\n defender = self.map.getUnitAt(self.pos)\\n attacker = self.selectedUnit\\n defender.takeDamage(int(attacker.firepower * attacker.hp))\\n attacker.takeDamage(int(defender.firepower * defender.hp))\\n self.endBattle()\",\n \"def start_soundtrack(self):\\n sources = screens['Combat']['music']\\n self.source = choice(sources)\\n Logger.info(\\n 'Application: Chose \\\"{}\\\" as the combat music.'.format(self.source)\\n )\\n try:\\n SoundManager.music[self.source]\\n except KeyError:\\n SoundManager.add_music(self.source, self)\\n SoundManager.play_music(self.source)\",\n \"def _starting_up():\\n global bus, skill_manager, event_scheduler\\n\\n bus.on('intent_failure', FallbackSkill.make_intent_failure_handler(bus))\\n\\n # Create the Intent manager, which converts utterances to intents\\n # This is the heart of the voice invoked skill system\\n service = IntentService(bus)\\n try:\\n PadatiousService(bus, service)\\n except Exception as e:\\n LOG.exception('Failed to create padatious handlers '\\n '({})'.format(repr(e)))\\n event_scheduler = EventScheduler(bus)\\n\\n # Create a thread that monitors the loaded skills, looking for updates\\n try:\\n skill_manager = SkillManager(bus)\\n except MsmException:\\n # skill manager couldn't be created, wait for network connection and\\n # retry\\n LOG.info('Msm is uninitialized and requires network connection',\\n 'to fetch skill information\\\\n'\\n 'Waiting for network connection...')\\n while not connected():\\n time.sleep(30)\\n skill_manager = SkillManager(bus)\\n\\n skill_manager.daemon = True\\n # Wait until priority skills have been loaded before checking\\n # network connection\\n skill_manager.load_priority()\\n skill_manager.start()\\n check_connection()\",\n \"def game_start():\\n herolist = Hero_List(hots_db)\\n heroclasses = []\\n for item in herolist:\\n heroclasses.append(Item(item, 'hero'))\\n curgame = Game(Team('home'), Team('enemy'), Team('hero_pool', heroclasses), '')\\n return curgame\",\n \"def start():\\r\\n introduction()\\r\\n score = duck_shooting1()\\r\\n dogs()\\r\\n play_again(score)\",\n \"def start_game(self):\\n while self.can_deal:\\n self.take_turn()\",\n \"def start(self):\\n\\n # Call the protected _turn method to start the game\\n self._turn()\",\n \"def start(self):\\n self.player = Player()\\n self.dealer = Dealer()\\n self.pot = 0\\n self.side_bet = 0\\n start_game()\",\n \"def start():\\n for m in motors:\\n m.run_direct()\",\n \"def start_game(self):\\n self._add_mines()\",\n \"def finish(self):\\n for char in self.characters.values():\\n character = char[\\\"char\\\"]\\n character.stop_auto_combat_skill()\\n\\n super(HonourAutoCombatHandler, self).finish()\",\n \"def startGame(self):\\n\\n\\t\\tfor name in self.players.keys():\\n\\t\\t\\tself.startPlayerGame((name, 0))\\n\\t\\tself.setupGuiSignals()\",\n \"def exec(self):\\n for player_id in range(0, 6):\\n ai_command = self.info_manager.get_player_tactic(player_id).exec()\\n self.info_manager.set_player_next_action(player_id, ai_command)\",\n \"def add_skill(skill_list, skill): #inputs the skill dictionary and skill\\r\\n\\tif skill==\\\"Gun Combat\\\":\\r\\n\\t\\tif stellagama.dice(1,6)>=3:\\r\\n\\t\\t\\tfor item in guns:\\r\\n\\t\\t\\t\\tif item in skill_list:\\r\\n\\t\\t\\t\\t\\tskill=item\\r\\n\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\tskill=stellagama.random_choice(guns)\\r\\n\\t\\telse:\\r\\n\\t\\t\\tskill=stellagama.random_choice(guns)\\r\\n\\telif skill in [\\\"Blade Combat\\\", \\\"Blade Cbt\\\"]:\\r\\n\\t\\tif stellagama.dice(1,6)>=3:\\r\\n\\t\\t\\tfor item in melee:\\r\\n\\t\\t\\t\\tif item in skill_list:\\r\\n\\t\\t\\t\\t\\tskill=item\\r\\n\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\tskill=stellagama.random_choice(melee)\\r\\n\\t\\telse:\\r\\n\\t\\t\\tskill=stellagama.random_choice(melee)\\r\\n\\telif skill==\\\"Vehicle\\\":\\r\\n\\t\\tif stellagama.dice(1,6)>=3:\\r\\n\\t\\t\\tfor item in vehicles:\\r\\n\\t\\t\\t\\tif item in skill_list:\\r\\n\\t\\t\\t\\t\\tskill=item\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tskill=stellagama.random_choice(vehicles)\\r\\n\\t\\telse:\\r\\n\\t\\t\\tskill=stellagama.random_choice(vehicles)\\r\\n\\tif skill in skill_list:\\r\\n\\t\\tskill_list[skill] += 1\\r\\n\\telif skill not in skill_list:\\r\\n\\t\\tskill_list[skill] = 1\\r\\n\\treturn skill_list #outputs the skill dictionary\\r\",\n \"def start(self, timed):\\n\\n if timed:\\n self._game = TimedGame(self._players)\\n else:\\n self._game = Game(self._players)\\n \\n self._game.start()\",\n \"async def start(self):\\n await self.on_start()\\n valid = await self.get_participants()\\n\\n if valid:\\n await asyncio.sleep(1)\\n await self.prepare()\\n await self.game()\\n\\n del started[started.index(self.channel.id)]\",\n \"def start_game(self, discord_id): # TODO replace with actual interface\\n\\n character = self.known_characters[discord_id]\\n self.current_character = character\\n character.start_game()\\n return character.first_output()\",\n \"def moove_character(self, case_list):\\n\\t\\tself.actual_hero.start_moove(case_list)\",\n \"def startDM(self):\\n self.uidm.startDM()\",\n \"def do (combat, investigator, monster):\\n if not arkham.SkillCheck (arkham.checkbase_will, -2) \\\\\\n .check (combat.game, investigator, monster):\\n arkham.horror_check_fail_hook (combat, investigator, monster)\\n arkham.combat_check_fail_hook (combat, investigator, monster)\\n arkham.combat_loop_hook (combat, investigator, monster)\\n else:\\n arkham.normal_fight_hook (combat, investigator, monster)\",\n \"def startMovementAll(self):\\n self.startMovementX()\\n self.startMovementY()\\n self.startMovementZ()\",\n \"def start(self):\\n self.__init__()\\n self.set_n_players()\\n self.init_players()\\n self.init_territory_selection_phase()\\n self.init_troop_deployment_phase()\\n # self.game_phase()\",\n \"def start(self):\\n for game_object in self.game_objects:\\n game_object.start()\\n # end for\\n self.time = time.time()\\n self.paused = False\\n self.running = True\\n print 'GAME STARTED'\",\n \"def start(self):\\n # Call the protected _turn method to start the game\\n self._end_time = time.time() + 60\\n self._turn()\",\n \"async def on_start(self):\\n m = \\\"**{}** has started a game of {}! To participate, say `I`! **{} players needed.**\\\".format(\\n self.message.author.display_name, self.name, self.num)\\n await client.say(self.message, m)\",\n \"def miner_begin_jumping(self, player):\\n\\n if self.onGround:\\n self.faceTowards(player)\\n self.ai_state = AI_JUMPING\\n self.ai_counter = 50\\n self.jump(self.direction_val*self.max_speed/2, self.max_speed)\\n self.changeAnimation('idle', self.direction_id) #TODO: use a jumping animation rather than an idle animation\\n self.weapon.update()\\n self.weapon.animation.synch_animation_frame(self.animation)\\n return\\n \\n #TODO: other case?\",\n \"def start_tournament(self):\\n cmd = '{}startTournament'.format(self.console)\\n self.write_command(cmd)\",\n \"def spawn(self):\\r\\n self.direction = utils.RANDOM.random()*math.pi*2 - math.pi\\r\\n self.redraw_image()\\r\\n self.speed = 0\\r\\n self.ammo = self.world.level.DEFAULT_AMMO\\r\\n self.alive = True\\r\\n self.kills = 0\\r\\n \\r\\n # Find a spawn point.\\r\\n # This loop might in theory take forever to return. In practice,\\r\\n # it returns within a reasonable number of iterations\\r\\n\\r\\n self.rect.center = self.team.get_spawn_point()\\r\\n while self.world.is_colliding(self):\\r\\n self.rect.centerx += utils.RANDOM.choice((-10, 10))\\r\\n self.rect.centery += utils.RANDOM.choice((-10, 10))\\r\\n self.rect.clamp_ip(self.world.rect) #never search outside the world\\r\\n \\r\\n #location keeps a floating point representation of the center of the\\r\\n #agent, mirroring the self.rect.center with higher precision.\\r\\n self.location = self.rect.center\\r\\n\\r\\n self.team.stats[\\\"spawns\\\"] += 1\",\n \"def start(self):\\n self.save_checkpoint(\\\"setup\\\")\\n\\n logging.info(\\\"Starting game...\\\")\\n body = render_message(\\n \\\"welcome.html\\\",\\n game_name=self.name,\\n night_end=self.night_end.strftime(\\\"%I:%M %p\\\"),\\n day_end=self.day_end.strftime(\\\"%I:%M %p\\\"),\\n players=self.game.players,\\n )\\n self.send_message(mafia.events.PUBLIC, \\\"%s: Start\\\" % self.name, body)\\n self.game.begin()\\n self.started = True\\n\\n self.save_checkpoint(\\\"start\\\")\",\n \"def do_attack_action(self, attack_action: action.Attack) -> None:\\n self.logger.debug(\\\"Executing action.Attack: %s\\\", attack_action)\\n self.reset_selection()\\n # First move the cursor on the attacking unit\\n first = MoveCursorAnimation(self.cursor.coord, attack_action.attacking.coord)\\n # Then select the attacking unit\\n first.next = SelectAndWait(attack_action.attacking.coord)\\n # Then move the cursor on the defending unit\\n first.next.next = MoveCursorAnimation(attack_action.attacking.coord, attack_action.defending.coord)\\n # Finally do the attack\\n first.next.next.next = room.RunRoomAsRoot(rooms.BattleAnimation(attack_action.attacking, attack_action.defending))\\n self.add_child(first)\",\n \"def ai(self):\\n if not self.alive:\\n return\\n\\n assert hasattr(self, 'net'), \\\"Bird has ai enabled but does not appear to have any agents\\\"\\n\\n self.birth_time += 1\\n\\n activation = self.net.activate(self.get_inputs())[0]\\n\\n # if activation > 1e3:\\n # print('unusually high activation of', activation)\\n\\n if activation > 0.9:\\n self.flap()\",\n \"def start(self) -> None:\\n\\n while True:\\n timetable = []\\n for bot in self.bots:\\n timetable.append(bot.next_send_time)\\n\\n val, idx = min((val, idx) for (idx, val) in enumerate(timetable))\\n sleep_time = val - time.time()\\n\\n if sleep_time > 0:\\n print(f\\\"Sleep for: {sleep_time}\\\")\\n time.sleep(sleep_time)\\n self.bots[idx].start()\",\n \"def play_game(self):\\n player = Player(input(\\\"What is your name?\\\"))\\n while player.health > 0:\\n input(\\\"Press t to start another turn\\\")\\n n = random.randint(0, 3)\\n if n == 0:\\n if self.monster_attack(player):\\n break\\n elif n == 1:\\n self.find_gold(player)\\n else:\\n print(\\\"Nothing happened!\\\")\",\n \"def testrandom(self):\\n for i in range(100):\\n WeaponAbility()\",\n \"def start_game(self):\\n\\n\\t\\tpass\",\n \"def _skills_manager_dispatch():\\n global ws\\n ws.emit(Message(\\\"skill_manager\\\", {}))\",\n \"async def ai(self, interaction: discord.Interaction, button: discord.ui.Button):\\n\\t\\tself.players.append(BattleshipAI(self.ctx.guild.me.display_name))\\n\\t\\tself.start.disabled = False\\n\\t\\tif len(self.players) >= self.max_players:\\n\\t\\t\\tview = None\\n\\t\\t\\tself.stop()\\n\\t\\telse:\\n\\t\\t\\tview = self\\n\\t\\tawait interaction.response.edit_message(content=self.generate_message(), view=view)\",\n \"def play(self):\\n self._play(self._move_person)\",\n \"def start_game(self) -> None:\\n self.init_game()\\n self.play()\",\n \"def start_game(self) -> None:\\n if self.started and not self.finished:\\n self.finish_game()\\n \\n self.started = True\\n self.finished = False\\n\\n self.game_count += 1\\n self.games_list[self.game_index] = {\\n \\\"total_kills\\\": 0,\\n \\\"players\\\": [],\\n \\\"kills\\\": {}\\n }\\n\\n return\",\n \"def __initSkills(self):\\n skills = self.teamparser.getPlayerSkills()\\n try:\\n skills = skills[(self.team, self.position)] #initial skills\\n except KeyError, err:\\n skills = []\\n raise TypeError, \\\"Invalid Team/Position: \\\" + self.team\\n for skill in skills:\\n skobj = pyBBSkill.BBSkill(skill, self.skillparser)\\n self.skills.append(skobj)\",\n \"def play_game(self):\\n # need everyone to pass to move to next phase?\\n self.deal_cards()\\n self.plant_food()\",\n \"def start_game(self, level: Level):\\n # Initialize game state and begin\\n self.game_state = Gamestate(level, len(self.player_list), 1, self.init_levels)\\n for player in self.player_list:\\n spawn_tile = self.game_state.get_random_spawn_tile()\\n self.game_state.add_character(player.entity, spawn_tile)\\n # First level has one zombie and no ghosts\\n first_zombie = EnemyZombie(\\\"zombie\\\", \\\"zombie\\\")\\n self.add_enemies(first_zombie)\\n for enemy in self.enemy_list:\\n enemy_spawn = self.game_state.get_random_spawn_tile()\\n self.game_state.add_adversary(enemy.entity, enemy_spawn)\",\n \"def spawn_players(self) -> None:\\n #Create the player\\n self.player1 = Player(self.sensitivity, self.screen_width, self.screen_height, self.screen_width//(3/2), self.screen_height-50, self.player_lives, self.fps, self.player1_bullet, Direction.UP, self.debug)\\n\\n #Create the AI\\n self.player2 = AIPlayer(self.sensitivity, self.screen_width, self.screen_height, self.screen_width//3, self.screen_height-50, self.player_lives, self.fps, self.player2_bullet, Direction.UP, 1, True, self.debug)\",\n \"def action_normal(self):\\n obs = self.observation\\n shoot = False\\n eb = self.__class__.enemy_base\\n \\n ammopacks = filter(lambda x: x[2] == \\\"Ammo\\\", obs.objects)\\n if ammopacks:\\n self.updateAllAmmoSpots(ammopacks)\\n # Walk to ammo\\n if obs.ammo < SUFFICIENT_AMMO:\\n self.goal = self.getClosestLocation(ammopacks)\\n self.motivation = MOTIVATION_AMMO\\n self.debugMsg(\\\"*> Recharge (%d,%d)\\\" % (self.goal[0],self.goal[1]))\\n \\n '''if (obs.ammo > 0 and obs.foes):\\n self.goal = self.getClosestLocation(obs.foes)\\n self.debugMsg(\\\"*> Go to enemy (%d,%d)\\\" % self.goal)\\n # If the enemy is within range, shoot.\\n if(point_dist(self.goal, obs.loc) < self.settings.max_range\\n and not line_intersects_grid(obs.loc, self.goal, self.grid, self.settings.tilesize)):\\n self.debugMsg(\\\"*> Shoot (%d,%d)\\\" % self.goal)\\n #if self.goal not in obs.friends:\\n self.motivation = MOTIVATION_SHOOT_TARGET\\n shoot = True'''\\n \\n # Attack strategy 1\\n #########################\\n # 1) Shoot live enemies #\\n #########################\\n # Aim at the closest enemy outside the enemy base\\n if obs.ammo > 0 and obs.foes:\\n living = filter(lambda x: point_dist(x[0:2], eb) > ENEMY_BASE_RANGE, obs.foes)\\n self.debugMsg(\\\"Living: %s\\\" % (living,))\\n if living:\\n self.debugMsg(1)\\n self.goal = min(living, key=lambda x: point_dist(obs.loc, x[0:2]))[0:2]\\n self.motivation = MOTIVATION_SHOOT_TARGET\\n self.debugMsg(2)\\n # Check if enemy in fire range\\n if (\\n point_dist(self.goal, obs.loc) < self.settings.max_range and\\n not line_intersects_grid(\\n obs.loc, \\n self.goal, \\n self.grid, \\n self.settings.tilesize\\n )\\n ):\\n self.debugMsg(3)\\n self.debugMsg(\\\"*> Shoot (%d,%d)\\\" % self.goal)\\n #return self.getActionTriple(True,None,0) ###?? SHOULD WE STOP MOVING WHEN WE SHOOT?\\n return self.getActionTriple(True)\\n else:\\n self.debugMsg(4)\\n return self.getActionTriple()\\n self.debugMsg(5)\\n \\n # Walk to an enemy CP\\n if self.goal is None and len(self.friendlyCPs) < 2:\\n self.goal = self.getClosestLocation(self.getQuietEnemyCPs())\\n if self.goal:\\n self.debugMsg(\\\"Crowded location: %d\\\" % self.getCrowdedValue(self.goal))\\n self.motivation = MOTIVATION_CAPTURE_CP\\n self.debugMsg(\\\"*> Capture (%d,%d)\\\" % (self.goal[0],self.goal[1]))\\n \\n '''# If you can't think of anything to do\\n # at least walk to a friendly control point\\n if self.goal is None:\\n self.goal = self.getClosestLocation(self.getQuietRestlessFriendlyCPs())\\n if self.goal:\\n self.motivation = MOTIVATION_GUARD_CP\\n self.debugMsg(\\\"*> Guard (%d,%d)\\\" % (self.goal[0],self.goal[1]))'''\\n \\n if self.goal is None:\\n self.goal = max(\\n self.__class__.ammoSpots,\\n key=lambda x: point_dist(x, obs.loc),\\n )\\n self.debugMsg(\\\"Going to ammospot far away (%d, %d)\\\" % (self.goal[0],self.goal[1]))\\n self.motivation = MOTIVATION_STAY_PUT\\n \\n\\n if self.goal:\\n return self.getActionTriple(shoot)\\n else:\\n return self.getActionTriple(shoot)\",\n \"def Start(self):\\n\\n # Keep updating until all agents have completed their waypoints\\n all_finished = False\\n while not all_finished:\\n all_finished = True\\n self.player_client.read()\\n for agent in self.agents:\\n all_finished = agent.update() and all_finished\",\n \"def run_ai(self):\\n state = self.brainstate\\n me = self.owner\\n if not self.owner.alive:\\n return\\n self._acquire_target()\\n if 'target' in state:\\n self._move_towards_target()\\n else:\\n # No target, wander around\\n if random.random() > 0.3:\\n possible_directions = [i for i in\\n ([-1, -1], [-1, 0], [-1, 1], [0, -1],\\n [0, 1], [1, -1], [1, 0], [1, 1])\\n if afr.map.map.tile_is_traversable(\\n me.x + i[0],\\n me.y + i[1]\\n )\\n ]\\n logging.debug(\\\"possible directions: %s\\\", possible_directions)\\n movement = random.choice(possible_directions)\\n me.x += movement[0]\\n me.y += movement[1]\",\n \"def setup_npcs(self):\\n super().setup_npcs()\\n npc_data = [\\n [Carrots, \\\"images/items/carrots.png\\\", 1, 220, 640],\\n [Mushroom, \\\"images/items/mushroom.png\\\", 1, 1028, 264],\\n [Grandma, \\\"images/people/grandma.png\\\", 3, 400, 400],\\n ]\\n for sprite_class, image, scale, x, y in npc_data:\\n sprite = sprite_class(resolve_resource_path(image), scale)\\n sprite.center_x = x\\n sprite.center_y = y\\n self.npc_list.append(sprite)\\n\\n grandma = self.npc_list[-1]\\n grandma.strategy = RandomWalk(0.05)\",\n \"def start_threaded_attack(\\n self, attack, wait=False, attributes=None):\\n attack_thread = threading.Thread(\\n target=attack,\\n args=([]))\\n attack_thread.start()\\n if wait:\\n attack_thread.join()\",\n \"def CombatAttack(self):\\n self.attacker.Attack(target=self.defender)\",\n \"def new_skill_interaction(self, skill):\\n self.skill_interact[skill] = True\",\n \"def install_default_skills(speak=True):\\n if exists(MSM_BIN):\\n p = subprocess.Popen(MSM_BIN + \\\" default\\\", stderr=subprocess.STDOUT,\\n stdout=subprocess.PIPE, shell=True)\\n (output, err) = p.communicate()\\n res = p.returncode\\n if res == 0 and speak:\\n # ws.emit(Message(\\\"speak\\\", {\\n # 'utterance': mycroft.dialog.get(\\\"skills updated\\\")}))\\n pass\\n elif not connected():\\n LOG.error('msm failed, network connection is not available')\\n ws.emit(Message(\\\"speak\\\", {\\n 'utterance': mycroft.dialog.get(\\\"no network connection\\\")}))\\n elif res != 0:\\n LOG.error('msm failed with error {}: {}'.format(res, output))\\n ws.emit(Message(\\\"speak\\\", {\\n 'utterance': mycroft.dialog.get(\\n \\\"sorry I couldn't install default skills\\\")}))\\n\\n else:\\n LOG.error(\\\"Unable to invoke Mycroft Skill Manager: \\\" + MSM_BIN)\",\n \"def cmd_start(update, context):\\n\\n context.bot.send_message(\\n chat_id=update.effective_chat.id,\\n text=f\\\"Halo salam kenal! Aku Bot dari Planet Ban {emo_heart_eyes}\\\")\",\n \"async def start(self, context):\\n try: \\n if context.author.is_mod:\\n self.tournament.start = True\\n self.tournament.clear_file()\\n await context.send('Arrancando el torneo manda !yo y tu nombre')\\n except Exception as error:\\n print(error)\",\n \"def create(self):\\n\\n self._calculate_hp()\\n self.race.alterAbilities()\\n self.race.racialAbilities()\",\n \"def all():\\n lab = test_loading()\\n\\n for _ in range(1):\\n print('🦅🐀🐙')\\n\\n test_spawn(lab)\\n\\n pc = test_spawn_player(lab)\\n\\n while True:\\n pc.store_move(PlayerMove(random.choice(['walk left', 'walk up', 'walk down', 'walk right'])))\\n test_turn_ai_and_players(lab)\\n if input() == '0':\\n break\",\n \"async def start(self, ctx):\\n if ctx.guild is None:\\n await ctx.reply(\\\"This command can only be used in a server, not in DMs.\\\")\\n raise commands.CommandError(\\\"Invoker not in a guild.\\\")\\n\\n if ctx.voice_client is None or ctx.voice_client.channel is None:\\n await ctx.reply(f\\\"I am not in a voice channel, invite me first with `{self.bot_config['prefix']}join`.\\\")\\n raise commands.CommandError(\\\"Bot not connected to a voice channel.\\\")\\n\\n if ctx.author.voice is None or ctx.author.voice.channel is None:\\n await ctx.reply(\\\"You need to be in a voice channel to use this command.\\\")\\n raise commands.CommandError(\\\"Invoker not connected to a voice channel.\\\")\\n\\n if ctx.voice_client is not None and ctx.author.voice.channel != ctx.voice_client.channel:\\n await ctx.reply(\\\"You need to be in the same voice channel as the bot to use this command.\\\")\\n raise commands.CommandError(\\\"Invoker not in same voice channel as bot.\\\")\\n\\n if ctx.voice_client is not None and ctx.voice_client.channel is not None:\\n controller = SpotifyController.get_instance(ctx.voice_client.channel.id)\\n if controller is None:\\n await ctx.reply(f\\\"I'm not playing anything at the moment.\\\")\\n raise commands.CommandError(\\\"Bot not connected to active spotify session.\\\")\\n else:\\n await ctx.reply(f\\\"I am not in a voice channel, invite me first with `{self.bot_config['prefix']}join`.\\\")\\n raise commands.CommandError(\\\"Bot not connected to a voice channel.\\\")\\n\\n queue, is_playing, current_index, current_progress_ms = controller.get_queue()\\n\\n if current_index is not None:\\n await ctx.reply(f\\\"I'm already playing the room playlist!\\\")\\n raise commands.CommandError(\\\"Bot not connected to a voice channel.\\\")\\n\\n controller.start_playback()\\n await ctx.message.add_reaction(\\\"👍\\\")\",\n \"def onSpawn(self):\\n self.spawned = True\\n self._interactor.initialiseDevices()\",\n \"def start(update, context):\\n context.bot.send_message(\\n chat_id=update.effective_chat.id, text=\\\"Hi human\\\")\",\n \"def start(msg: telebot.types.Message):\\n logger.info(f'New /start command from id: {msg.from_user.id}.')\\n\\n bot.send_message(\\n msg.from_user.id,\\n 'Hello, welcome to TicTacDrop!',\\n reply_markup=buttons.get_play_markup()\\n )\\n\\n utils.save_user(msg.from_user)\",\n \"def explode(self):\\n\\n self.hit = True\\n self.max_speed = 135\\n self.destruction_sound.play()\\n self.death_animation_timer.start()\\n self.image = DESTRO_ENEMY\",\n \"def fight(self, combat_item):\\r\\n print(self.name + \\\" doesn't want to fight with you\\\")\\r\\n return True\",\n \"def resetSkills(self):\\r\\n \\\"\\\"\\\" Reset the default attributes \\\"\\\"\\\"\\r\\n self.player['level'] = 1\\r\\n self.player['xp'] = 0\\r\\n self.player['credits'] = int(startCredits)\\r\\n self.player['popup'] = int(popupStatus)\\r\\n self.player['name'] = self.player.name\\r\\n self.player['lastconnected'] = int(time.time())\\r\\n\\r\\n \\r\\n \\\"\\\"\\\" Iterate through the skills list then set each skill to 0 \\\"\\\"\\\"\\r\\n for skill in skills:\\r\\n self.player[skill.name] = 0\\r\\n\\r\\n \\\"\\\"\\\" Slay the player \\\"\\\"\\\"\\r\\n es.server.queuecmd(\\\"damage %s %s\\\" % (self.userid, es.getplayerprop(self.userid, \\\"CBasePlayer.m_iHealth\\\")))\\r\\n \\r\\n \\\"\\\"\\\" Notify the user \\\"\\\"\\\"\\r\\n tell(self.userid, 'info deleted')\",\n \"def run_game(self) -> None:\\n decision = 0\\n if self._initial:\\n self._initial = False\\n while decision != 1:\\n try:\\n display_no_combat_init(self.hero)\\n decision = get_user_input([1, 2, -1])\\n if decision == -1:\\n self._quit()\\n elif decision == 2:\\n self._show_bag()\\n else:\\n break\\n except KeyboardInterrupt:\\n print(\\\"[!] If you want to quit, use the provided user interface\\\")\\n\\n while not self.hero.is_dead:\\n try:\\n self._load_map()\\n except KeyboardInterrupt:\\n print(\\\"[!] If you want to quit, use the provided user interface\\\")\",\n \"def start(self, world):\\n self.sense(world)\",\n \"def skills_manager(message):\\n global skills_manager_timer\\n\\n if connected():\\n if skills_manager_timer is None:\\n pass\\n # Install default skills and look for updates via Github\\n LOG.debug(\\\"==== Invoking Mycroft Skill Manager: \\\" + MSM_BIN)\\n install_default_skills(False)\\n\\n # Perform check again once and hour\\n skills_manager_timer = Timer(3600, _skills_manager_dispatch)\\n skills_manager_timer.daemon = True\\n skills_manager_timer.start()\",\n \"def on_attack(self, target, friendly):\\n # Get buff from Dread Admiral Eliza\\n if self.race == 'pirate' or self.race == 'all':\\n eliza_buff_atk, eliza_buff_dfs = friendly.friendly_eliza_buff\\n for each in friendly.minions:\\n each.get_buff(eliza_buff_atk, eliza_buff_dfs)\\n\\n # If divine shield, not getting hurt\\n if not self.divine_shield:\\n self.hurt = True\\n if not target.divine_shield:\\n target.hurt = True\",\n \"def play(self):\\n print(f\\\"Welcome, to the Adventure games.\\\\n\\\"\\n \\\"May the randomly generated numbers be ever in your favour.\\\\n\\\"\\n f\\\"\\\\n{adventure.current_room.description}\\\")\\n\\n # Prompt the user for commands until they've won the game.\\n while not self.won():\\n # This method for FORCED only works on Small and Tiny,\\n # it works until the end of CrowtherRooms, when FORCED is not the\\n # only possible direction for a room. I am working on fixing this,\\n # and I think I'm very close, but I won't be able to fix it in time.\\n # I can send that version it by e-mail though, if you want!\\n\\n # For now, this handles the FORCED movements\\n if len(adventure.current_room.connection) == 1:\\n adventure.move(\\\"FORCED\\\")\\n if adventure.current_room.id in self.idlist:\\n print(adventure.current_room.name)\\n else:\\n print(adventure.current_room.description)\\n if len(adventure.current_room.inventory.itemlist) > 0:\\n for item in adventure.current_room.inventory.itemlist:\\n print(f\\\"{item.name}: {item.description}\\\")\\n\\n # Get a new direction from the user\\n command = input(\\\"> \\\")\\n command = command.upper()\\n movements = [\\n \\\"NORTH\\\", \\\"SOUTH\\\", \\\"EAST\\\", \\\"WEST\\\", \\\"UP\\\", \\\"DOWN\\\",\\n \\\"OUT\\\", \\\"IN\\\", \\\"XYZZY\\\", \\\"WAVE\\\", \\\"WATER\\\", \\\"JUMP\\\"]\\n abbreviations = {\\n \\\"Q\\\": \\\"QUIT\\\", \\\"L\\\": \\\"LOOK\\\", \\\"I\\\": \\\"INVENTORY\\\", \\\"N\\\": \\\"NORTH\\\",\\n \\\"S\\\": \\\"SOUTH\\\", \\\"E\\\": \\\"EAST\\\", \\\"W\\\": \\\"WEST\\\", \\\"U\\\": \\\"UP\\\", \\\"D\\\": \\\"DOWN\\\"}\\n if command in abbreviations and len(command) == 1:\\n command = abbreviations[command]\\n\\n # Check if the command is a valid movement\\n if command in movements and self.current_room.isvalid(command):\\n\\n # Print appropriate room name/description after moving\\n self.idlist.append(adventure.current_room.id)\\n adventure.move(command)\\n if adventure.current_room.id in self.idlist:\\n print(adventure.current_room.name)\\n else:\\n print(adventure.current_room.description)\\n\\n # Print current room's inventory\\n for item in adventure.current_room.inventory.itemlist:\\n print(f\\\"{item.name}: {item.description}\\\")\\n\\n # Handle any additional commands\\n elif command == \\\"HELP\\\":\\n print(f\\\"You can move by typing directions such as EAST/WEST/IN/OUT\\\\n\\\"\\n \\\"QUIT quits the game.\\\\n\\\"\\n \\\"HELP prints instructions for the game.\\\\n\\\"\\n \\\"INVENTORY lists the item in your inventory.\\\\n\\\"\\n \\\"LOOK lists the complete description of the room and its contents.\\\\n\\\"\\n \\\"TAKE <item> take item from the room.\\\\n\\\"\\n \\\"DROP <item> drop item from your inventory.\\\")\\n elif command == \\\"QUIT\\\":\\n print(\\\"Thanks for playing!\\\")\\n exit(0)\\n elif command == \\\"LOOK\\\":\\n print(adventure.current_room.description)\\n if len(adventure.current_room.inventory.itemlist) > 0:\\n for item in adventure.current_room.inventory.itemlist:\\n print(f\\\"{item.name}: {item.description}\\\")\\n elif len(command.split()) > 1:\\n if command.split()[0] == \\\"TAKE\\\":\\n adventure.take(command.split()[1])\\n elif command.split()[0] == \\\"DROP\\\":\\n adventure.drop(command.split()[1])\\n elif command == \\\"INVENTORY\\\":\\n if len(self.player.itemlist) > 0:\\n for item in self.player.itemlist:\\n print(f\\\"{item.name}: {item.description}\\\")\\n else:\\n print(\\\"Your inventory is empty.\\\")\\n else:\\n print(\\\"Invalid command.\\\")\\n exit(0)\",\n \"def start(self):\\n for trial in self._trials:\\n self._run(trial)\",\n \"def at_start(self):\\n if not self.db.started:\\n self.player.start()\\n self.db.started = True\",\n \"def setup(self):\\n\\n # Sprite lists\\n self.all_sprite_list = arcade.SpriteList()\\n self.player_list = arcade.SpriteList()\\n self.coin_list = arcade.SpriteList()\\n self.deathclaw_list = arcade.SpriteList()\\n # Score\\n self.score = 0\\n\\n # Set up the player\\n # Character image from https://www.pngkit.com/\\n self.player_sprite = arcade.Sprite(\\\"Vault_Boy.png\\\", SPRITE_SCALING_PLAYER)\\n self.player_sprite.center_x = 50\\n self.player_sprite.center_y = 50\\n self.player_list.append(self.player_sprite)\\n\\n # Create the ENEMY\\n for i in range(DEATHCLAW_COUNT):\\n\\n # Create the ENEMY instance\\n # ENEMY image from https://fallout.fandom.com/\\n deathclaw = Deathclaw(\\\"Deathclaw.png\\\", SPRITE_SCALING_DEATHCLAW)\\n\\n # Position the coin\\n deathclaw.center_x = random.randrange(SCREEN_WIDTH)\\n deathclaw.center_y = random.randrange(SCREEN_HEIGHT)\\n\\n # Add the coin to the lists\\n self.deathclaw_list.append(deathclaw)\\n\\n for i in range(COIN_COUNT):\\n\\n # Create the Nuka Cola instance\\n # Nuka Cola image fromh https://www.cleanpng.com/free/nuka-cola.html\\n coin = Coin(\\\"Nuka_Kola.png\\\", SPRITE_SCALING_COIN)\\n\\n # Position the coin\\n coin.center_x = random.randrange(SCREEN_WIDTH)\\n coin.center_y = random.randrange(SCREEN_HEIGHT)\\n\\n # Add the coin to the lists\\n self.coin_list.append(coin)\",\n \"def startRandom(session):\\n rarity = Rarities.getRandomRarity()\\n # Select a random quest from the database based on the random % rarity\\n quest = None\\n while True:\\n # Rpeat this process until you get a not already active/valid/enabled quest\\n quest = session.query(Quest).filter(Quest.rarity == rarity).order_by(func.random()).first()\\n #TODO: isQuestActive()\\n \\n if quest.is_active == True and quest.isActive(session) == False:\\n break\\n\\n activequest = QuestActive(time_stop = datetime.datetime.now() + datetime.timedelta(days = quest.interval_days),\\n quest = quest\\n )\\n print(\\\"Started random quest %s\\\" % (quest.id))\\n session.add(activequest)\\n session.commit()\\n return quest.id\",\n \"def attack(self):\\n if not self.attack_mode and not self.damage_mode and not self.death_mode:\\n self.attack_group = choice(self.attack_groups)\\n self.attack_mode = True\\n self.cut_frame_update = 0\",\n \"def attack(self, enemy_squads_list, army_name):\\n enemy = SQUAD_STRATEGIES[self.strategy](enemy_squads_list)\\n attacker_success = self.calc_squad_attack_success()\\n attacker_damage = self.calc_squad_damage()\\n\\n enemy_success = enemy.calc_squad_attack_success()\\n print(f'{army_name} attack_success = {attacker_success} - enemy attack_success = {enemy_success}')\\n if attacker_success <= enemy_success:\\n return {\\n \\\"success\\\": 'lost',\\n \\\"damage\\\": 0,\\n }\\n enemy.take_damage(attacker_damage)\\n self.update_soldier_experience()\\n self.update_units_time_last_attack()\\n print(f'{army_name} caused damage = {attacker_damage}, enemy squad health = {enemy.squad_health()}')\\n return {\\n \\\"success\\\": 'win',\\n \\\"damage\\\": attacker_damage,\\n }\",\n \"def plant_food(self):\\n self.phase.set(0)\\n #self.broadcast_phase()\\n self.players[self.first_player].take_turn()\",\n \"def activate(self):\\n self.robot = self.behavior_system.robot\\n self.cozmo = self.robot.cozmo\\n\\n # Play the animation\\n try:\\n self.angry_anim = self.cozmo.play_anim_trigger(cozmosdk.anim.Triggers.DriveStartAngry)\\n self.angry_anim.on_completed(lambda evt, **kwargs: self._angry_anim_completed(evt))\\n except:\\n pass\",\n \"def level_time_simulate(start_levels, attack_style, attack_bonus, strength_bonus):\\n ticks_per_attack = 4 # Scimitar attack speed\\n enemy_health = 60 # Sand crab health\\n\\n max_hit, accuracy = get_max_hit_and_accuracy(\\n start_levels, attack_style, attack_bonus, strength_bonus)\\n \\n if attack_style == Attack_Style.ATTACK:\\n start_exp = osrs.experience[start_levels.attack]\\n end_exp = osrs.experience[start_levels.attack+1]\\n elif attack_style == Attack_Style.STRENGTH:\\n start_exp = osrs.experience[start_levels.strength]\\n end_exp = osrs.experience[start_levels.strength+1]\\n \\n experience = end_exp - start_exp\\n avg_ticks = combat_simulator.ticks_until_exp(max_hit, accuracy,\\n ticks_per_attack, enemy_health, experience,\\n osrs.BASE_EXP_PER_DAMAGE, ITERATIONS)\\n return avg_ticks\",\n \"def start(self, agents):\\n self.current_state = self.startState()\\n self.agents = agents\\n for i,agent in enumerate(self.agents):\\n agent.setPlayerId(i)\\n\\n return self.current_state\",\n \"def move_me_on_spawn(self):\\r\\n\\t\\tif self.points_to_go:\\r\\n\\t\\t\\tself.start_pos = self.points_to_go[0]\\r\\n\\t\\t\\tfor point in self.points_to_go[1:]:\\r\\n\\t\\t\\t\\tfor i in range(len(self.points_to_go[1:])):\\r\\n\\t\\t\\t\\t\\tself.goal_pos = self.points_to_go[i]\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\tself.move_me()\\r\\n\\t\\t\\t\\t\\t#self.start_pos = \\r\\n\\t\\t\\t\\t\\t#print(self.goal_pos)\\r\\n\\t\\t\\t\\t\\t#if self.move_me():\\r\\n\\t\\t\\t\\t\\t#\\ti += 1\\r\\n\\t\\t\\t\\t\\t#\\tprint('switch')\\r\",\n \"def do_eat(self, args):\\n\\n name = pick(\\\"Agent\\\", self.model.get_agent_names())\\n if name is not None:\\n food = int(input(\\\"Food to eat?\\\"))\\n agent = self.model.get_agent(name)\\n agent.eat(food)\",\n \"def start():\\n commands = {\\\"new tournament\\\": Controller.new_tournament,\\n \\\"new round\\\": Controller.new_round,\\n \\\"new player\\\": Controller.new_player,\\n\\n \\\"set round\\\": Controller.set_round,\\n \\\"set player\\\": Controller.set_player,\\n\\n \\\"get players -all -alpha\\\": Controller.get_all_players_alpha,\\n \\\"get players -all -rank\\\": Controller.get_all_players_rank,\\n \\\"get players -alpha\\\": Controller.get_players_alpha,\\n \\\"get players -rank\\\": Controller.get_players_rank,\\n\\n \\\"get tournament -all\\\": Controller.get_all_tournaments,\\n \\\"get tournament\\\": Controller.get_tournament,\\n\\n \\\"get round -all\\\": Controller.get_all_rounds,\\n \\\"get round\\\": Controller.get_round,\\n\\n \\\"get match -all\\\": Controller.get_all_matches,\\n \\\"get match\\\": Controller.get_match,\\n\\n \\\"load\\\": Controller.load,\\n\\n \\\"exit\\\": Controller.close_app\\n }\\n\\n # At the beginning of the program, load all data from a data_base.\\n Controller.load()\\n print(\\\"Need help? Type 'commands' to see all commands and there purposes.\\\")\\n\\n while True:\\n instruction = str(input(\\\"ChessManager >>> \\\"))\\n try:\\n commands[instruction]()\\n except KeyError:\\n print(\\\"Wrong Command.\\\")\",\n \"def on_pre_enter(self):\\n Logger.info('Application: Changed to the Combat screen.')\\n Logger.info(\\n 'Application: '\\n 'The ship chosen for combat is the '\\n '\\\"{}\\\" type.'.format(self.player.type)\\n )\\n Logger.info('Application: Stats: {}.'.format(self.player.stats))\\n self.start_soundtrack()\\n\\n # Set the event interval of every frame\\n self.updater = Clock.schedule_interval(self.update, 1.0/60.0)\\n\\n # Populate round/level objects and collidable lists\\n self.collidables = []\\n self.spaceships = []\\n\\n # Sets the combat stage/hostiles based on players level\\n self.set_level_hostiles()\\n\\n\\n for asteroid in self.asteroids:\\n self.collidables.append(asteroid)\\n for ship in self.spaceships:\\n self.collidables.append(ship)\",\n \"def actions_turn(positions, player1, player2, creatures):\\n\\n attacking = []\\n moving = []\\n\\n # Split the orders within attacks and movements\\n for character in positions:\\n if character in creatures:\\n if positions[character]['order'] == 'attack':\\n attacking += character\\n else:\\n moving += character\\n elif character in player1:\\n if positions[character]['order'] == 'attack':\\n attacking += character\\n else:\\n moving += character\\n\\n else:\\n if positions[character]['order'] == 'attack':\\n attacking += character\\n else:\\n moving += character\\n\\n # Execute the attacks\\n for character in attacking:\\n # First attacking : the creatures\\n if character in creatures:\\n hero_name = character\\n name_attack = positions[character]['name_attack']\\n attack_coord = positions[character]['where']\\n attack(positions, hero_name, name_attack, (0, 0), attack_coord, player1, player2, creatures)\\n # Then the heroes of the first player\\n elif character in player1:\\n hero_name = character\\n name_attack = positions[character]['name_attack']\\n attack_coord = positions[character]['where']\\n attack(positions, hero_name, name_attack, (0, 0), attack_coord, player1, player2, creatures)\\n # Finally the ones of the second player\\n else:\\n hero_name = character\\n name_attack = positions[character]['name_attack']\\n attack_coord = positions[character]['where']\\n attack(positions, hero_name, name_attack, (0, 0), attack_coord, player1, player2, creatures)\\n\\n for character in moving:\\n print(character, moving)\\n # First moving : the creatures\\n if character in creatures:\\n hero_name = character\\n movement_coord = positions[character]['where']\\n move(hero_name, positions, movement_coord)\\n\\n # Then the heroes of the first player\\n elif character in player1:\\n hero_name = character\\n movement_coord = positions[character]['where']\\n move(hero_name, positions, movement_coord)\\n\\n # Finally the ones of the second player\\n else:\\n hero_name = character\\n movement_coord = positions[character]['where']\\n move(hero_name, positions, movement_coord)\\n\\n return player1, player2, positions, creatures\",\n \"async def play_axe(game_state) -> None:\\n if len(game_state.active_player.zombies) > 0:\\n play_weapon(game_state, Supply.AXE)\\n else:\\n game_state.active_player.print(f'You cannot play {Supply.AXE.value} for nothing!')\",\n \"def execute_for_command(self, skill_input: SkillInput, services: AssistantServicesBase):\\n voice = skill_input.adjective.lower()\\n if voice in (\\\"female\\\", \\\"male\\\"):\\n services.settings_service.voice = voice\\n services.settings_service.save_settings()\\n services.user_interaction_service.speak('Okay, I will use a %s voice from now on.' % (voice), True)\\n else:\\n services.user_interaction_service.speak('I don\\\\'t understand what voice you want')\",\n \"def _do_start(self, chat_id, user_id, args, update):\\n \\n self.tclient.send_message('Hallo! Ich bin ein Bot, um dir zu helfen, dir deine Nasensprüche zu merken!', chat_id)\",\n \"def loadallskills(self):\\r\\n for skill in os.listdir( os.path.join( es.getAddonPath( info.basename ), \\\"skills\\\" )):\\r\\n es.load(\\\"%s/skills/%s\\\" % (info.basename, skill))\",\n \"def attack_target_mob(self, text_input, dam_mod=None, success_verb=None, fail_verb=None, outcome=f\\\"\\\"):\\n # TODO: Time to kill bats and goblins is good (2-3 rounds, max end is 5-6 with bad luck).\\n # TODO: They hit too frequently/do too much damage without being able to heal or mitigate damage.\\n # TODO: Add in heal ability/potions (how to make it useful, but not too easy? - extended CD?)\\n # TODO: Increase monster EXP to reduce levelling rate (too slow ATM).\\n # TODO: Damage mitigation via armor (both reduce to-hit and reduce damage amount?)\\n entry = f\\\"\\\"\\n target, search_term = search(self, text_input, \\\"room.mobs\\\")\\n Report = namedtuple(\\\"Report\\\", (\\\"success\\\", \\\"target\\\"))\\n if target:\\n # Just going to have the player attack the first mob of that type in the room for now. I'll figure out how\\n # I want to do selection later.\\n mob = target[0]\\n attack = attack_action(self, mob, dam_mod)\\n if attack.hit:\\n if success_verb:\\n attack_verb = f\\\"{success_verb} the {mob}\\\"\\n else:\\n attack_verb = (\\n f\\\"{self.equipped_weapon.main_hand.success_verb} the {mob} with your \\\"\\n f\\\"{self.equipped_weapon.main_hand.name}\\\"\\n )\\n if attack.hit_type == \\\"hit\\\":\\n entry += f\\\"You {attack_verb}\\\"\\n elif attack.hit_type == \\\"crit\\\":\\n entry += f\\\"You savagely {attack_verb}\\\"\\n entry += f\\\" for {attack.damage} damage\\\"\\n if mob.current_hp <= 0:\\n self.xp += mob.xp\\n entry += (\\n f\\\", killing it!\\\\n\\\"\\n f\\\"You gain {mob.xp} xp.\\\"\\n )\\n mob.kill_monster()\\n else:\\n entry += f\\\"{outcome}.\\\\n\\\"\\n else:\\n if fail_verb:\\n attack_verb = f\\\"{fail_verb} the {mob}\\\"\\n else:\\n attack_verb = (\\n f\\\"{self.equipped_weapon.main_hand.fail_verb} the {mob} with your \\\"\\n f\\\"{self.equipped_weapon.main_hand.name}\\\"\\n )\\n entry += f\\\"You {attack_verb} but\\\"\\n if attack.hit_type == \\\"miss\\\":\\n entry += (\\n f\\\" missed.\\\"\\n )\\n if attack.hit_type == \\\"dodge\\\":\\n entry += (\\n f\\\" the {mob} dodged out of the way.\\\"\\n )\\n self.add_messages(entry)\\n self.journal.add_entry(f\\\"(Round {self.turn_counter}): \\\" + entry)\\n return Report(attack.hit, mob)\\n else:\\n self.add_messages(f\\\"You do not see one of those.\\\")\\n return Report(False, None)\",\n \"def bcp_game_start(self, **kargs):\\n self.bcp_player_add(number=1)\\n self.bcp_player_turn_start(player=1)\\n self.events.post('game_started', **kargs)\",\n \"def fireMyWeapons(self):\\n for myWeapon in self.readyWeapons:\\n myWeapon.fire()\\n\\n self.readyWeapons = []\",\n \"def start_stage2(ai_settings,boss,ship):\\n\\t\\tpygame.mixer.music.load('sounds/lvl2.mp3')\\n\\t\\tpygame.mixer.music.set_volume(1.5)\\n\\t\\tpygame.mixer.music.play()\\n\\t\\tai_settings.ui_text_color = (255, 0, 0)\\n\\t\\tai_settings.bg_color = (255, 255, 255)\\n\\t\\tai_settings.boss_speed_factor = 12\\n\\t\\tai_settings.boss_bullet_speed_factorD = 15\\n\\t\\tai_settings.boss_bullet_speed_factor = 15\\n\\t\\tai_settings.boss_bullet_color = (0, 0, 0)\\n\\t\\tai_settings.boss_health = 5000\\n\\t\\tboss.image = pygame.image.load('images/boss2.bmp')\\n\\t\\tship.second_stage = True\\n\\t\\tai_settings.boss_direction *= -1\",\n \"async def giveaway_start(self, ctx):\\n\\n game = await self._get_random_game()\\n if game is None:\\n await ctx.reply(\\\"No more games!\\\")\\n return\\n\\n giveaway_id = await self._create_giveaway(game['game_id'])\\n giveaway_data = await self._get_giveaway(giveaway_id)\\n\\n self._tasks[giveaway_id] = self.bot.loop.create_task(\\n self.giveaway_task(\\n ctx,\\n giveaway_data=giveaway_data,\\n timeout=None,\\n )\\n )\",\n \"def squad_attacks(self, attacker, defender):\\n\\n for unit in attacker.units:\\n if(len(defender.units) != 0):\\n if(unit.hit):\\n enemy = R.choice(defender.units)\\n enemy.damage_inflicte(unit.beat(enemy))\\n else:\\n return\",\n \"def onStart(self, agent):\\n\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68635476","0.61531","0.6022753","0.60088336","0.5843919","0.58394575","0.5778643","0.56064093","0.5535863","0.55134916","0.5509995","0.5499876","0.54166967","0.5389035","0.53655183","0.536523","0.53433776","0.53231376","0.5306996","0.52780104","0.5273676","0.5249844","0.5235796","0.5226684","0.52134466","0.5200757","0.51975447","0.5188341","0.51822466","0.51699317","0.5152293","0.5124889","0.51176673","0.51056","0.51037335","0.51021403","0.51012063","0.5086441","0.50859874","0.5069663","0.5065657","0.50510746","0.5048421","0.50463235","0.5032101","0.5024898","0.5014908","0.49890086","0.49793944","0.49757433","0.4973842","0.49672636","0.49623784","0.49601692","0.49590132","0.49560046","0.4934753","0.49282277","0.49225855","0.49222535","0.49158683","0.49124476","0.4905818","0.48980016","0.489129","0.4889107","0.48838845","0.48830777","0.4882553","0.4876188","0.4873354","0.48692065","0.48686364","0.48660308","0.4851945","0.4847506","0.4846275","0.48403502","0.48395854","0.4836247","0.48333097","0.48279685","0.48256806","0.48251143","0.48163748","0.48143026","0.48135224","0.480363","0.48027354","0.48002365","0.4798988","0.47864193","0.47827107","0.4782617","0.47789398","0.47764748","0.47734287","0.47569352","0.47524756","0.47501433"],"string":"[\n \"0.68635476\",\n \"0.61531\",\n \"0.6022753\",\n \"0.60088336\",\n \"0.5843919\",\n \"0.58394575\",\n \"0.5778643\",\n \"0.56064093\",\n \"0.5535863\",\n \"0.55134916\",\n \"0.5509995\",\n \"0.5499876\",\n \"0.54166967\",\n \"0.5389035\",\n \"0.53655183\",\n \"0.536523\",\n \"0.53433776\",\n \"0.53231376\",\n \"0.5306996\",\n \"0.52780104\",\n \"0.5273676\",\n \"0.5249844\",\n \"0.5235796\",\n \"0.5226684\",\n \"0.52134466\",\n \"0.5200757\",\n \"0.51975447\",\n \"0.5188341\",\n \"0.51822466\",\n \"0.51699317\",\n \"0.5152293\",\n \"0.5124889\",\n \"0.51176673\",\n \"0.51056\",\n \"0.51037335\",\n \"0.51021403\",\n \"0.51012063\",\n \"0.5086441\",\n \"0.50859874\",\n \"0.5069663\",\n \"0.5065657\",\n \"0.50510746\",\n \"0.5048421\",\n \"0.50463235\",\n \"0.5032101\",\n \"0.5024898\",\n \"0.5014908\",\n \"0.49890086\",\n \"0.49793944\",\n \"0.49757433\",\n \"0.4973842\",\n \"0.49672636\",\n \"0.49623784\",\n \"0.49601692\",\n \"0.49590132\",\n \"0.49560046\",\n \"0.4934753\",\n \"0.49282277\",\n \"0.49225855\",\n \"0.49222535\",\n \"0.49158683\",\n \"0.49124476\",\n \"0.4905818\",\n \"0.48980016\",\n \"0.489129\",\n \"0.4889107\",\n \"0.48838845\",\n \"0.48830777\",\n \"0.4882553\",\n \"0.4876188\",\n \"0.4873354\",\n \"0.48692065\",\n \"0.48686364\",\n \"0.48660308\",\n \"0.4851945\",\n \"0.4847506\",\n \"0.4846275\",\n \"0.48403502\",\n \"0.48395854\",\n \"0.4836247\",\n \"0.48333097\",\n \"0.48279685\",\n \"0.48256806\",\n \"0.48251143\",\n \"0.48163748\",\n \"0.48143026\",\n \"0.48135224\",\n \"0.480363\",\n \"0.48027354\",\n \"0.48002365\",\n \"0.4798988\",\n \"0.47864193\",\n \"0.47827107\",\n \"0.4782617\",\n \"0.47789398\",\n \"0.47764748\",\n \"0.47734287\",\n \"0.47569352\",\n \"0.47524756\",\n \"0.47501433\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.841464"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76298,"cells":{"query":{"kind":"string","value":"Finish a combat. Send results to players, and kill all failed characters."},"document":{"kind":"string","value":"def finish(self):\n for char in self.characters.values():\n character = char[\"char\"]\n character.stop_auto_combat_skill()\n\n super(HonourAutoCombatHandler, self).finish()"},"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 leave_combat(self):\n self.__regen()","def endBattle(self):\n self.map.removeDead()\n self.cancelAttackMode()\n self.deselectUnit()","def endCompetition(self):\n self.robot_exit = True","def finish(self, npc, world):\n pass","def finishTurn(self):\n print \"go\"\n sys.stdout.flush()","def die(self):\n self.got_killed = True\n CharacterDeath(self).dispatch() # used by the GA","def EndTurn(self):\n\n if self.defender.health <= 0:\n print(\"{0} ran out of health and passed out, {1} is the victor!\".format(self.defender.name, self.attacker.name))\n return True\n self.currentTurn += 1\n if self.currentTurn >= self.maxTurns:\n print(\"Both parties got bored of the fight and parted ways, draw!\")\n return True\n self.attacker, self.defender = self.defender, self.attacker\n return False","def finish(text):\n finish.has_been_called = True\n print(\"{}{}\".format(success, text))","def finish():\n pass","async def end(ctx):\n if ctx.message.channel.name.lower() not in tod_channels:\n return\n\n room = ctx.message.channel.name.lower()\n if room not in tod_games:\n await amor_manager.say(\"Truth Or Dare not in progress in {}\".format(room))\n else:\n host = tod_games[room]['host']\n await amor_manager.say(\"Game Over in {}! Thank you to {} for hosting this game!\".format(room, host))\n del tod_games[room]","def endgame(self):\n #reveals the dealer's first card then the dealer hits until the dealer's hand's value is above 16\n self.dealer_hand[0].face_up()\n if self.dealer_hand[0].value in FACE_CARDS:\n self.dealer_value += 10\n elif self.dealer_hand[0].value == \"A\":\n self.dealer_value += 11\n self.dealer_ace_count += 1\n else:\n self.dealer_value += int(self.dealer_hand[0].value)\n\n if self.dealer_value > 21:\n if self.dealer_ace_count > self.dealer_almost_bust:\n #To prevent a Bust, the Dealer's Ace became a one\n self.dealer_value -= 10\n self.dealer_almost_bust += 1\n else:\n self.player_win()\n #House always wins Ties\n elif self.dealer_value == 21:\n self.player_lose()\n\n while self.dealer_value < 17:\n self.hit(\"dealer\")\n\n if (self.player_value - self.dealer_value) > 0:\n self.player_win()\n else:\n self.player_lose()","def endGame(self):\n pass","async def on_end(self, game_result: Result):","def gameEnd():\n result = cs411_game.gameEnd(request.form.get('Games_Game_ID'),\n\trequest.form.get('Contestant_Coontestant_ID'))\n if result == 1: return prepJSON({\"message\": \"success\"})\n else: raise InvalidUsage(result[\"message\"], 403)","def finish():","def finish():","def finish():","def finish():","def end(self):\n winners = mafia.str_player_list(self.game.winners())\n logging.info(\"Game over! Winners: %s\" % winners)\n\n subject = \"%s: The End\" % self.name\n body = \"Game over!\\n\\nCongratulations to %s for a well \" \\\n \"(or poorly; I can't tell) played game!\" % winners\n self.send_message(mafia.events.PUBLIC, subject, body)","def end_game(self):\n if self._waiting_for_players:\n [p.client.cancel_interactions() for p in self.all_players]\n self._waiting_for_players = False\n\n super().end_game()\n\n self.states[self.state][\"next\"] = \"STOP\"\n self._run_next_state()","def end(self, won, reason):\n pass\n # replace with your end logic","def end(self):\n self.my_print(\"\\t[DONE]\", msg_types.INFO)\n self.in_progress = False","def quit_game(self):\n self.done = True","async def endGame(self, ctx):\n print(\"Ending game ...\")\n await self.movePlayer(ctx=ctx, voiceChannel=self.lastVoiceChannel, reason=\"Fin de partie.\")\n await self.deleteCategory(ctx=ctx, reason=\"Fin de partie.\")\n await self.deleteRole(ctx=ctx, reason=\"Fin de partie.\")\n print(\"Game ended\")\n await self.delete()","def finish(self):\r\n self.start_finish()\r\n self.wait_finish()","def on_death(self):\n self.bark('I was killed.')\n self.where = self.category.spawn\n self.life = self.life_max\n for this in self.battle_set.get().npcs.all():\n this.delete()\n # self.cool -= 9001\n self.save()\n return True","def _handle_completed_characters(self, completed_before_turn):\n completed_after_turn = self.game_state.get_completed_characters().copy()\n completed_chars = list(set(completed_after_turn).difference(set(completed_before_turn)))\n players = [player for player in self.player_list if player.entity in completed_chars]\n for player in players:\n player.notify(self._format_move_result_notification(None, Moveresult.EXIT))\n self.turn_order.eject(player)","def __end_turn(self):\n self._turn_counter += 1\n # päivittää pelaajan\n self._player %=2\n self._player += 1\n if (self._gui):\n self.__status[\"text\"] = self._player_names[self._player-1]\n self.__turn_counter_label[\"text\"]= \"{}. Turns taken\".format\\\n (self._turn_counter)\n self.__turn_counter_label.update()\n\n # This will cause stackoverflow in training.\n if (self._state == PLAY and self.__check_ai_turn()):\n self.__ai_turn()","def end(self):\n self._log.debug('%s: doing ..', __class__.__name__)\n self._log.debug('%s: done.', __class__.__name__)","def endMyTurn(self):\n try:\n result = self.game.server.endEmpireTurn(self.game.authKey)\n if result == 0:\n if self.game.myEmpire['roundComplete'] == 1:\n self.modeMsgBox('You have now un-ended your turn')\n self.game.myEmpire['roundComplete'] = 0\n else:\n self.modeMsgBox('Your turn has been ended, thankyou')\n self.game.myEmpire['roundComplete'] = 1\n self.mainmenu.writeTextRoundEnds()\n elif type(result) == types.StringType:\n self.modeMsgBox(result)\n else:\n \"\"\"End Turn and wait for it to end\"\"\"\n result = self.game.server.endRound(self.game.authKey)\n self.game.server.logout(self.game.authKey)\n from anw.modes.modelogin import ModeLogin\n newMode = ModeLogin(self.game, 200)\n self.game.enterMode(newMode)\n except:\n self.modeMsgBox('endMyTurn->Connection to Server Lost')","def _end(self):\n\n self.logger.msg1(\"Done\")","def finish(self) -> None:\n self.__exit__(None, None, None)","def defend(user: \"PlayerCharacter or Monster\"):\n user.defend = True\n user.wait = int(0.4 * (100 - user.stats[\"SPEED\"]))","def end_turn(self, end_msg):\n self.progress_bar.set_value(self.word_view.word)\n self.greeterboard.greets(end_msg)\n self.scoreboard.update_score()\n self.word_view.update_word()\n self.greeterboard.update_gallows()","def finish(self):\r\n\r\n self._is_finished = True","def bandit_camp_alladin():\n\n alladin_hum = enemies.alladin_hum()\n os.system(\"clear\")\n print(\"YOU BLOODY BASTARD!! YOU KILLED MY COMRADES!!\")\n time.sleep(1)\n for i in range(2):\n print(\".\")\n time.sleep(1)\n print(\"You won't leave this cave alive! I am Alladin the Prince of Thieves!\")\n time.sleep(2)\n print(\"Prepare to die!!!!!!!!!!!\")\n print()\n input(\"Press Enter to continue...\")\n return combat.combat(alladin_hum)","def finish(self, finish_time=None):\n pass","def _end_episode(self):\n self.turn_cnt = 0\n self.episode_cnt += 1\n self.contexts = None\n self.seed_utterances = None\n self.reset_agents()","def api_end_game(self):\n pass","def episode_finish(self, reason: str) -> None:\n pass","async def end(self, roles, dialogs):\n self.ended = True","def finish(self):\n if self.state == STATE_FINISH_ERROR:\n self.on_error('Something went wrong. :( Please see log.')\n else:\n self.on_finish()\n self.log_file.close()\n self.state = STATE_TERMINAL","async def finish_game(self, game_id, channel):\n game = await self.get_game(game_id)\n player1_score = await self.get_player_total(game[1])\n player2_score = await self.get_player_total(game[2])\n if player2_score < 12 and self.check_if_bot(game[2]):\n await self.add_card(game[2])\n else:\n winner = self.determine_winner(player1_score, player2_score)\n player1_current_bal = await ex.u_currency.get_balance(game[1])\n player2_current_bal = await ex.u_currency.get_balance(game[2])\n if winner == 'player1':\n await ex.u_currency.update_balance(game[1], player1_current_bal + int(game[4]))\n if not self.check_if_bot(game[2]):\n await ex.u_currency.update_balance(game[2], player2_current_bal - int(game[4]))\n await self.announce_winner(channel, game[1], game[2], player1_score, player2_score, game[4])\n elif winner == 'player2':\n if not self.check_if_bot(game[2]):\n await ex.u_currency.update_balance(game[2], player2_current_bal + int(game[3]))\n await ex.u_currency.update_balance(game[1], player1_current_bal - int(game[3]))\n await self.announce_winner(channel, game[2], game[1], player2_score, player1_score, game[3])\n elif winner == 'tie':\n await self.announce_tie(channel, game[1], game[2], player1_score)\n await self.delete_game(game_id)","def bcp_game_end(self, **kwargs):\n self.player = None\n self.events.post('game_ended', **kwargs)","def done(exit = True, result = main_result):\n failures = result.failed\n result.finish()\n if exit:\n sys.exit(failures)","def end_episode(self, outcome: int, alive: bool, success: bool):\n self._say('Episode completed, my reward is {}'.format(outcome))","def end_turn(self):\n for _ in range(self._hand.size()):\n card = self._hand.pop()\n self._discard.push(card)\n\n for _ in range(self._active.size()):\n card = self._active.pop()\n self._discard.push(card)\n\n for _ in range(self._handsize):\n if self._deck.size() == 0:\n self._discard.shuffle_collection()\n self._deck.replace(self._discard)\n self._discard.clear_collection()\n card = self._deck.pop()\n self._hand.push(card)\n self._money = 0\n self._attack = 0","def finish(self):\n pass","def finish(self):\n pass","def endGame(self):\n #self.active = False\n self.inGame = False\n self.hand = []\n self.position = None","def finish_goal(self, goal_handle, result, text=\"\"):\n goal_handle.set_succeeded(result, text)\n self.set_goal_done()","def finish(self):\n with self._lock: # just to be tidy; lock not really needed to set a boolean\n self._done = True","def test_finish_draw(self):\n game = self.ending(['bbw.wwww'], 8, 1)\n game.man_move(0, 3)\n self.assertTrue(game.finished)","def end_turn(self):\r\n self.turn += 1","def end(self):\n\n # if the device is a PBR, try to turn off the pump before ending. In case of problems, keep trying for\n # 3 minutes before giving up.\n if self.device_details['device_type'] == 'PBR':\n pump_id = self.device_details['setup']['pump_id']\n counter = 0\n while counter < 60:\n try:\n result = True, self.device.set_pump_state(pump_id, False)\n except Exception as e:\n result = False, e\n\n response = [(datetime.datetime.utcnow().strftime(\"%Y-%m-%d %H:%M:%S\")),\n self.device_details['node_id'],\n self.device_details['device_type'],\n 8,\n [pump_id, False],\n result,\n 'internal']\n\n self.log.update_log(*response) # log the change in pump state (or the cause of failure)\n\n # end the loop if the pump has been successfully turned off\n if result[0]:\n break\n else:\n counter += 1\n sleep(3)\n\n self.device.disconnect()","def defend(self, damage_amt):\n total_kills = 0\n teams_total_defense = 0\n for hero in self.heroes:\n teams_total_defense += hero.defend()\n excess_total = damage_amt - teams_total_defense\n self.deal_damage(excess_total)\n\n for hero in self.heroes:\n if hero.health <= 0:\n total_kills += 1\n return total_kills","async def complete(self, ctx: commands.Context, *, text: str):\n # Check for cooldown\n await self.check_cooldown(ctx)\n\n # Send the text to API without a context\n async with ctx.typing():\n result = await utils.create_completion_result(self.bot.loop, prompt=text, temperature=.8, max_tokens=64,\n stop=\"\\n\", engine=\"davinci\")\n await ctx.send(text + result)","def end_game(self, end_msg):\n self.word_view.reveal_word()\n self.greeterboard.update_gallows()\n self.greeterboard.greets(end_msg)","def end_game(self):\n self.game.stop_running()","def Finish(self):\n pass","def finish(self):\n if self.failed:\n print \"%s failed. %s of %s assertions passed.\" % (\n self.failed, self.passed, self.failed + self.passed)\n else:\n print \"%s of %s assertions passed.\" % (self.passed, self.passed)\n\n self.failed = self.passed = 0","def finish(self):\n if self.serial:\n self.serial.close()","def end_turn(entity: EntityID, time_spent: int):\n if entity == get_turn_holder():\n world.spend_time(entity, time_spent)\n next_turn()\n else:\n logging.warning(f\"Tried to end {world.get_name(entity)}'s turn but they're not turn holder.\")","def _finish(self):\n steppable_registry = CompuCellSetup.persistent_globals.steppable_registry\n steppable_registry.finish()\n self.close_frames()","def endgame(winner):","def end(self):\r\n if self._background_worker_pool:\r\n if self._aborted:\r\n self.log(Report.INFO, \"Aborting background workers.\")\r\n self._background_worker_pool.abort()\r\n else:\r\n self.log(Report.INFO, \"Waiting for background workers to finish.\")\r\n self._background_worker_pool.shutdown()\r\n self.report.end_workunit(self._background_root_workunit)\r\n self._background_root_workunit.end()\r\n\r\n if self._foreground_worker_pool:\r\n if self._aborted:\r\n self.log(Report.INFO, \"Aborting foreground workers.\")\r\n self._foreground_worker_pool.abort()\r\n else:\r\n self.log(Report.INFO, \"Waiting for foreground workers to finish.\")\r\n self._foreground_worker_pool.shutdown()\r\n\r\n self.report.end_workunit(self._main_root_workunit)\r\n self._main_root_workunit.end()\r\n\r\n outcome = self._main_root_workunit.outcome()\r\n if self._background_root_workunit:\r\n outcome = min(outcome, self._background_root_workunit.outcome())\r\n outcome_str = WorkUnit.outcome_string(outcome)\r\n log_level = WorkUnit.choose_for_outcome(outcome, Report.ERROR, Report.ERROR,\r\n Report.WARN, Report.INFO, Report.INFO)\r\n self.log(log_level, outcome_str)\r\n\r\n if self.run_info.get_info('outcome') is None:\r\n try:\r\n self.run_info.add_info('outcome', outcome_str)\r\n except IOError:\r\n pass # If the goal is clean-all then the run info dir no longer exists...\r\n\r\n self.report.close()\r\n self.upload_stats()","def StartCombat(self):\n\n print(\"------------------------------------\")\n self.fighter1.PrintInfo()\n self.fighter2.PrintInfo()\n print(\"------------------------------------\")\n self.combatInProgress = True\n while self.combatInProgress and self.currentTurn < self.maxTurns:\n print(\"Turn {}:\".format(self.currentTurn))\n self.CombatAttack()\n if self.EndTurn():\n print(\"------------------------------------\")\n break\n print(\"------------------------------------\")\n time.sleep(3)","def send_finish_event(self):\n self.status['type'] = '__end__'\n self._send()","def end_game(self):\n print(str(self.__players[0]._Player__name) + \" score is: \"\n + str(self.__fields[0].score))\n print(str(self.__players[1]._Player__name) + \" score is: \"\n + str(self.__fields[1].score))\n Game.play = False","def finish(self) -> None:","def finish(self) -> None:","def onFinish(self):\n self.finalizeStats()","def run_combat(self, monster1, monster2):\n\n ce = combat_engine.CombatEngine(monster1, monster2, log_ref=self)\n ce.run_combat()","def finish_failed_goal(self, goal_handle, text=\"\"):\n result = self.generate_grip_result(GripperResult.FAILURE)\n self.finish_goal(goal_handle, result, text)","def start_finish(self):\r\n self.send_queue.put(('finish',))","def finish(self, success, msg=\"\"):\n if success is True:\n print(\"All sequences were downloaded correctly. Good!\")\n if self.gui == 0:\n sys.exit(\"Program finished without error.\")\n else:\n self.finished.emit(\"Download finished successfully!\")\n raise ProgramDone\n\n else:\n if self.gui == 0:\n sys.exit(\"Program finished with some failures.\\n\" + msg)\n else:\n self.finished.emit(\"Program finished with some \"\n \"failures.\\n\" + msg)\n raise ProgramDone","def finish_game(self) -> bool:\n if not self.started and self.finished:\n return\n\n self.started = False\n self.finished = True\n\n players_list = self.games_list[self.game_index][\"players\"]\n self.games_list[self.game_index][\"players\"] = \\\n list(dict.fromkeys(players_list))\n\n return","def finish(self):","def finish(self):","def end_game(self, winner):\n reward = self.reward(winner)\n if self.learning:\n self.q_values[self.represent_state(self.prev_state), self.prev_action] += self.alpha * (\n reward - self.prev_q_val)\n self.log(\"the winner is {0}\".format(winner))\n self.prev_state = None\n self.prev_action = None\n self.prev_q_val = 0\n self.winner = VALUES.NOT_FINISHED","def stand(self):\n self.endgame()","def finish_command(self):\n if self.validate(False):\n self.player_ships[self.values[0]] = self.values[1]\n # Example Output:\n # {'n': [[(0, 0), (1, 0), (2, 0), (3, 0)]],\n # 'b': [[(1, 1), (2, 1), (3, 1), (4, 1)], [(2, 2), (2, 3), (2, 4)]]}\n print(self.player_ships)\n self.cancel()","def Finish(self):\n if self.verbose:\n\n print \"Finishing simulation\"\n\n for s in self._schedulees:\n\n s.Finish()","def finish(self, result=CallResult.no_result):\n assert not self.state is CallState.finished\n\n self.state = CallState.finished\n self.finish_time = time()\n self.result = result","def end(self):\n self.kill_flag.value = True\n while (not self.pseye.thread_complete.value) or (not self.saver.saving_complete.value):\n pass","def onFinished( self, resultLine ):\n\t\treturn self.agi.finish()","def endEmpireTurn(self, myEmpire):\n try:\n # end the Empire's turn\n myEmpire.endTurn()\n \n # check if all Empires turns are done\n done = 1\n for empireID, myEmpire in self.empires.iteritems():\n if myEmpire.roundComplete == 0 and myEmpire.ai == 0:\n done = 0\n break\n return done\n except:\n return 'galaxy->endEmpireTurn error'","def end(self, text):\n if text is None:\n string = self._build_string(\"Completed!\")\n else:\n string = self._build_string(text)\n out.write(\"\\r\" + string + \"\\n\")\n out.flush()","def finish(self):\n if not self.finishTime:\n self.stop()\n report = [\n \"flush script \" + str(self.runTime) + \" seconds\",\n \"compute time \" + str(self.computeTime) + \" seconds\",\n \"parse time \" + str(self.parseTime) + \" seconds\",\n \"internal xfer time \" + str(self.transferTime) + \" seconds\",\n \"output size \" + str(self.outputSize),\n \"input size \" + str(self.inputSize),\n \"intermediate size \" + str(self.intermedSize),\n \"overall tree width \" + str(self.dagWidth),\n \"local slots \" + str(self.task.config.execLocalSlots)]\n joined = \"\\n\".join(report) \n log.info(joined)\n print joined","def end(self):\n self._log.debug('doing ..')\n super().end()\n\n self._log.debug('done')","def battle(hero, boss, spells, hard=False):\n effects = {}\n step = 0\n while True:\n # Run current after effects\n for k,v in effects.items():\n e = v[0]\n e(hero, boss)\n # print 'Running effect', e.func_name\n del v[0]\n if not v:\n del effects[k]\n\n # print 'Step %d' % step\n if step % 2 == 0:\n if hard:\n hero.hit -= 1\n if hero.is_dead:\n return 'lose'\n\n # Play magician\n # No more spell ?\n if step / 2 >= len(spells):\n return 'moar'\n\n spell = spells[step/2]\n\n # no more mana ?\n cost = all_spells[spell]\n if hero.mana < cost:\n return 'lose'\n\n # Check spell is not in effects\n if spell in effects:\n return 'invalid'\n\n # Run spell\n # print 'Running', spell.func_name\n # Remove mana used by spell\n after = spell(hero, boss)\n hero.mana -= cost\n if after:\n # Run first effect\n after[0](hero, boss)\n del after[0]\n\n # Save after effects\n effects[spell] = after\n\n # print 'Hero -> %s' % boss\n\n else:\n # Play boss\n damage = max(1, boss.damage - hero.armor)\n hero.hit -= damage\n # print 'Boss -> %s' % hero\n\n # Win / lose ?\n if hero.is_dead:\n return 'lose'\n if boss.is_dead:\n return 'win'\n\n step += 1","def end_conversation(self, fname=None):\n if fname: self.save_conversation(fname)\n self.current_summary = ''\n self.current_persona = ''\n self.current_img_path = ''\n self.current_gender = ''\n self.cached_query = ''\n self.user_turns.clear()\n self.gpt3_turns.clear()","def end(self, win):\n if win:\n print('\\033[92m', \"task won.\", '\\033[0m')\n if self._win_sound is not None:\n self.sound_player.play(self._win_sound)\n else:\n print('\\033[91m', \"task lost\", '\\033[0m')\n if self._loose_sound is not None:\n self.sound_player.play(self._loose_sound)\n if self._fulfill_if_lost:\n self.force_fulfill()\n\n # removing the loose task\n if self._loose_task is not None:\n self.gameEngine.taskMgr.remove(self._loose_task)\n if self._to_do_task is not None:\n self.gameEngine.taskMgr.remove(self._to_do_task)\n\n # starting the next step\n self.gameEngine.scenario.start_next_step()","def finish_game(self, z):\n for move in self.moves: # add this game winner result to all past moves.\n move += [z]","def fight(self, combat_item):\r\n if combat_item == self.weakness:\r\n print(\"You fend \" + self.name + \" off with the \" + combat_item )\r\n Character.victory_count +=1\r\n return True\r\n else:\r\n print(self.name + \" crushes you, puny adventurer\")\r\n return False","def end():\n return say()","def end():\n logging.info(\"Execution Ended\")","def finish_subsystem(self):\n self.__channel.close()","def die(self):\n\t\tself.game.end()\n\t\tsuper(Ship, self).die()","def Finish(self):\n\t\n self.queue.join()"],"string":"[\n \"def leave_combat(self):\\n self.__regen()\",\n \"def endBattle(self):\\n self.map.removeDead()\\n self.cancelAttackMode()\\n self.deselectUnit()\",\n \"def endCompetition(self):\\n self.robot_exit = True\",\n \"def finish(self, npc, world):\\n pass\",\n \"def finishTurn(self):\\n print \\\"go\\\"\\n sys.stdout.flush()\",\n \"def die(self):\\n self.got_killed = True\\n CharacterDeath(self).dispatch() # used by the GA\",\n \"def EndTurn(self):\\n\\n if self.defender.health <= 0:\\n print(\\\"{0} ran out of health and passed out, {1} is the victor!\\\".format(self.defender.name, self.attacker.name))\\n return True\\n self.currentTurn += 1\\n if self.currentTurn >= self.maxTurns:\\n print(\\\"Both parties got bored of the fight and parted ways, draw!\\\")\\n return True\\n self.attacker, self.defender = self.defender, self.attacker\\n return False\",\n \"def finish(text):\\n finish.has_been_called = True\\n print(\\\"{}{}\\\".format(success, text))\",\n \"def finish():\\n pass\",\n \"async def end(ctx):\\n if ctx.message.channel.name.lower() not in tod_channels:\\n return\\n\\n room = ctx.message.channel.name.lower()\\n if room not in tod_games:\\n await amor_manager.say(\\\"Truth Or Dare not in progress in {}\\\".format(room))\\n else:\\n host = tod_games[room]['host']\\n await amor_manager.say(\\\"Game Over in {}! Thank you to {} for hosting this game!\\\".format(room, host))\\n del tod_games[room]\",\n \"def endgame(self):\\n #reveals the dealer's first card then the dealer hits until the dealer's hand's value is above 16\\n self.dealer_hand[0].face_up()\\n if self.dealer_hand[0].value in FACE_CARDS:\\n self.dealer_value += 10\\n elif self.dealer_hand[0].value == \\\"A\\\":\\n self.dealer_value += 11\\n self.dealer_ace_count += 1\\n else:\\n self.dealer_value += int(self.dealer_hand[0].value)\\n\\n if self.dealer_value > 21:\\n if self.dealer_ace_count > self.dealer_almost_bust:\\n #To prevent a Bust, the Dealer's Ace became a one\\n self.dealer_value -= 10\\n self.dealer_almost_bust += 1\\n else:\\n self.player_win()\\n #House always wins Ties\\n elif self.dealer_value == 21:\\n self.player_lose()\\n\\n while self.dealer_value < 17:\\n self.hit(\\\"dealer\\\")\\n\\n if (self.player_value - self.dealer_value) > 0:\\n self.player_win()\\n else:\\n self.player_lose()\",\n \"def endGame(self):\\n pass\",\n \"async def on_end(self, game_result: Result):\",\n \"def gameEnd():\\n result = cs411_game.gameEnd(request.form.get('Games_Game_ID'),\\n\\trequest.form.get('Contestant_Coontestant_ID'))\\n if result == 1: return prepJSON({\\\"message\\\": \\\"success\\\"})\\n else: raise InvalidUsage(result[\\\"message\\\"], 403)\",\n \"def finish():\",\n \"def finish():\",\n \"def finish():\",\n \"def finish():\",\n \"def end(self):\\n winners = mafia.str_player_list(self.game.winners())\\n logging.info(\\\"Game over! Winners: %s\\\" % winners)\\n\\n subject = \\\"%s: The End\\\" % self.name\\n body = \\\"Game over!\\\\n\\\\nCongratulations to %s for a well \\\" \\\\\\n \\\"(or poorly; I can't tell) played game!\\\" % winners\\n self.send_message(mafia.events.PUBLIC, subject, body)\",\n \"def end_game(self):\\n if self._waiting_for_players:\\n [p.client.cancel_interactions() for p in self.all_players]\\n self._waiting_for_players = False\\n\\n super().end_game()\\n\\n self.states[self.state][\\\"next\\\"] = \\\"STOP\\\"\\n self._run_next_state()\",\n \"def end(self, won, reason):\\n pass\\n # replace with your end logic\",\n \"def end(self):\\n self.my_print(\\\"\\\\t[DONE]\\\", msg_types.INFO)\\n self.in_progress = False\",\n \"def quit_game(self):\\n self.done = True\",\n \"async def endGame(self, ctx):\\n print(\\\"Ending game ...\\\")\\n await self.movePlayer(ctx=ctx, voiceChannel=self.lastVoiceChannel, reason=\\\"Fin de partie.\\\")\\n await self.deleteCategory(ctx=ctx, reason=\\\"Fin de partie.\\\")\\n await self.deleteRole(ctx=ctx, reason=\\\"Fin de partie.\\\")\\n print(\\\"Game ended\\\")\\n await self.delete()\",\n \"def finish(self):\\r\\n self.start_finish()\\r\\n self.wait_finish()\",\n \"def on_death(self):\\n self.bark('I was killed.')\\n self.where = self.category.spawn\\n self.life = self.life_max\\n for this in self.battle_set.get().npcs.all():\\n this.delete()\\n # self.cool -= 9001\\n self.save()\\n return True\",\n \"def _handle_completed_characters(self, completed_before_turn):\\n completed_after_turn = self.game_state.get_completed_characters().copy()\\n completed_chars = list(set(completed_after_turn).difference(set(completed_before_turn)))\\n players = [player for player in self.player_list if player.entity in completed_chars]\\n for player in players:\\n player.notify(self._format_move_result_notification(None, Moveresult.EXIT))\\n self.turn_order.eject(player)\",\n \"def __end_turn(self):\\n self._turn_counter += 1\\n # päivittää pelaajan\\n self._player %=2\\n self._player += 1\\n if (self._gui):\\n self.__status[\\\"text\\\"] = self._player_names[self._player-1]\\n self.__turn_counter_label[\\\"text\\\"]= \\\"{}. Turns taken\\\".format\\\\\\n (self._turn_counter)\\n self.__turn_counter_label.update()\\n\\n # This will cause stackoverflow in training.\\n if (self._state == PLAY and self.__check_ai_turn()):\\n self.__ai_turn()\",\n \"def end(self):\\n self._log.debug('%s: doing ..', __class__.__name__)\\n self._log.debug('%s: done.', __class__.__name__)\",\n \"def endMyTurn(self):\\n try:\\n result = self.game.server.endEmpireTurn(self.game.authKey)\\n if result == 0:\\n if self.game.myEmpire['roundComplete'] == 1:\\n self.modeMsgBox('You have now un-ended your turn')\\n self.game.myEmpire['roundComplete'] = 0\\n else:\\n self.modeMsgBox('Your turn has been ended, thankyou')\\n self.game.myEmpire['roundComplete'] = 1\\n self.mainmenu.writeTextRoundEnds()\\n elif type(result) == types.StringType:\\n self.modeMsgBox(result)\\n else:\\n \\\"\\\"\\\"End Turn and wait for it to end\\\"\\\"\\\"\\n result = self.game.server.endRound(self.game.authKey)\\n self.game.server.logout(self.game.authKey)\\n from anw.modes.modelogin import ModeLogin\\n newMode = ModeLogin(self.game, 200)\\n self.game.enterMode(newMode)\\n except:\\n self.modeMsgBox('endMyTurn->Connection to Server Lost')\",\n \"def _end(self):\\n\\n self.logger.msg1(\\\"Done\\\")\",\n \"def finish(self) -> None:\\n self.__exit__(None, None, None)\",\n \"def defend(user: \\\"PlayerCharacter or Monster\\\"):\\n user.defend = True\\n user.wait = int(0.4 * (100 - user.stats[\\\"SPEED\\\"]))\",\n \"def end_turn(self, end_msg):\\n self.progress_bar.set_value(self.word_view.word)\\n self.greeterboard.greets(end_msg)\\n self.scoreboard.update_score()\\n self.word_view.update_word()\\n self.greeterboard.update_gallows()\",\n \"def finish(self):\\r\\n\\r\\n self._is_finished = True\",\n \"def bandit_camp_alladin():\\n\\n alladin_hum = enemies.alladin_hum()\\n os.system(\\\"clear\\\")\\n print(\\\"YOU BLOODY BASTARD!! YOU KILLED MY COMRADES!!\\\")\\n time.sleep(1)\\n for i in range(2):\\n print(\\\".\\\")\\n time.sleep(1)\\n print(\\\"You won't leave this cave alive! I am Alladin the Prince of Thieves!\\\")\\n time.sleep(2)\\n print(\\\"Prepare to die!!!!!!!!!!!\\\")\\n print()\\n input(\\\"Press Enter to continue...\\\")\\n return combat.combat(alladin_hum)\",\n \"def finish(self, finish_time=None):\\n pass\",\n \"def _end_episode(self):\\n self.turn_cnt = 0\\n self.episode_cnt += 1\\n self.contexts = None\\n self.seed_utterances = None\\n self.reset_agents()\",\n \"def api_end_game(self):\\n pass\",\n \"def episode_finish(self, reason: str) -> None:\\n pass\",\n \"async def end(self, roles, dialogs):\\n self.ended = True\",\n \"def finish(self):\\n if self.state == STATE_FINISH_ERROR:\\n self.on_error('Something went wrong. :( Please see log.')\\n else:\\n self.on_finish()\\n self.log_file.close()\\n self.state = STATE_TERMINAL\",\n \"async def finish_game(self, game_id, channel):\\n game = await self.get_game(game_id)\\n player1_score = await self.get_player_total(game[1])\\n player2_score = await self.get_player_total(game[2])\\n if player2_score < 12 and self.check_if_bot(game[2]):\\n await self.add_card(game[2])\\n else:\\n winner = self.determine_winner(player1_score, player2_score)\\n player1_current_bal = await ex.u_currency.get_balance(game[1])\\n player2_current_bal = await ex.u_currency.get_balance(game[2])\\n if winner == 'player1':\\n await ex.u_currency.update_balance(game[1], player1_current_bal + int(game[4]))\\n if not self.check_if_bot(game[2]):\\n await ex.u_currency.update_balance(game[2], player2_current_bal - int(game[4]))\\n await self.announce_winner(channel, game[1], game[2], player1_score, player2_score, game[4])\\n elif winner == 'player2':\\n if not self.check_if_bot(game[2]):\\n await ex.u_currency.update_balance(game[2], player2_current_bal + int(game[3]))\\n await ex.u_currency.update_balance(game[1], player1_current_bal - int(game[3]))\\n await self.announce_winner(channel, game[2], game[1], player2_score, player1_score, game[3])\\n elif winner == 'tie':\\n await self.announce_tie(channel, game[1], game[2], player1_score)\\n await self.delete_game(game_id)\",\n \"def bcp_game_end(self, **kwargs):\\n self.player = None\\n self.events.post('game_ended', **kwargs)\",\n \"def done(exit = True, result = main_result):\\n failures = result.failed\\n result.finish()\\n if exit:\\n sys.exit(failures)\",\n \"def end_episode(self, outcome: int, alive: bool, success: bool):\\n self._say('Episode completed, my reward is {}'.format(outcome))\",\n \"def end_turn(self):\\n for _ in range(self._hand.size()):\\n card = self._hand.pop()\\n self._discard.push(card)\\n\\n for _ in range(self._active.size()):\\n card = self._active.pop()\\n self._discard.push(card)\\n\\n for _ in range(self._handsize):\\n if self._deck.size() == 0:\\n self._discard.shuffle_collection()\\n self._deck.replace(self._discard)\\n self._discard.clear_collection()\\n card = self._deck.pop()\\n self._hand.push(card)\\n self._money = 0\\n self._attack = 0\",\n \"def finish(self):\\n pass\",\n \"def finish(self):\\n pass\",\n \"def endGame(self):\\n #self.active = False\\n self.inGame = False\\n self.hand = []\\n self.position = None\",\n \"def finish_goal(self, goal_handle, result, text=\\\"\\\"):\\n goal_handle.set_succeeded(result, text)\\n self.set_goal_done()\",\n \"def finish(self):\\n with self._lock: # just to be tidy; lock not really needed to set a boolean\\n self._done = True\",\n \"def test_finish_draw(self):\\n game = self.ending(['bbw.wwww'], 8, 1)\\n game.man_move(0, 3)\\n self.assertTrue(game.finished)\",\n \"def end_turn(self):\\r\\n self.turn += 1\",\n \"def end(self):\\n\\n # if the device is a PBR, try to turn off the pump before ending. In case of problems, keep trying for\\n # 3 minutes before giving up.\\n if self.device_details['device_type'] == 'PBR':\\n pump_id = self.device_details['setup']['pump_id']\\n counter = 0\\n while counter < 60:\\n try:\\n result = True, self.device.set_pump_state(pump_id, False)\\n except Exception as e:\\n result = False, e\\n\\n response = [(datetime.datetime.utcnow().strftime(\\\"%Y-%m-%d %H:%M:%S\\\")),\\n self.device_details['node_id'],\\n self.device_details['device_type'],\\n 8,\\n [pump_id, False],\\n result,\\n 'internal']\\n\\n self.log.update_log(*response) # log the change in pump state (or the cause of failure)\\n\\n # end the loop if the pump has been successfully turned off\\n if result[0]:\\n break\\n else:\\n counter += 1\\n sleep(3)\\n\\n self.device.disconnect()\",\n \"def defend(self, damage_amt):\\n total_kills = 0\\n teams_total_defense = 0\\n for hero in self.heroes:\\n teams_total_defense += hero.defend()\\n excess_total = damage_amt - teams_total_defense\\n self.deal_damage(excess_total)\\n\\n for hero in self.heroes:\\n if hero.health <= 0:\\n total_kills += 1\\n return total_kills\",\n \"async def complete(self, ctx: commands.Context, *, text: str):\\n # Check for cooldown\\n await self.check_cooldown(ctx)\\n\\n # Send the text to API without a context\\n async with ctx.typing():\\n result = await utils.create_completion_result(self.bot.loop, prompt=text, temperature=.8, max_tokens=64,\\n stop=\\\"\\\\n\\\", engine=\\\"davinci\\\")\\n await ctx.send(text + result)\",\n \"def end_game(self, end_msg):\\n self.word_view.reveal_word()\\n self.greeterboard.update_gallows()\\n self.greeterboard.greets(end_msg)\",\n \"def end_game(self):\\n self.game.stop_running()\",\n \"def Finish(self):\\n pass\",\n \"def finish(self):\\n if self.failed:\\n print \\\"%s failed. %s of %s assertions passed.\\\" % (\\n self.failed, self.passed, self.failed + self.passed)\\n else:\\n print \\\"%s of %s assertions passed.\\\" % (self.passed, self.passed)\\n\\n self.failed = self.passed = 0\",\n \"def finish(self):\\n if self.serial:\\n self.serial.close()\",\n \"def end_turn(entity: EntityID, time_spent: int):\\n if entity == get_turn_holder():\\n world.spend_time(entity, time_spent)\\n next_turn()\\n else:\\n logging.warning(f\\\"Tried to end {world.get_name(entity)}'s turn but they're not turn holder.\\\")\",\n \"def _finish(self):\\n steppable_registry = CompuCellSetup.persistent_globals.steppable_registry\\n steppable_registry.finish()\\n self.close_frames()\",\n \"def endgame(winner):\",\n \"def end(self):\\r\\n if self._background_worker_pool:\\r\\n if self._aborted:\\r\\n self.log(Report.INFO, \\\"Aborting background workers.\\\")\\r\\n self._background_worker_pool.abort()\\r\\n else:\\r\\n self.log(Report.INFO, \\\"Waiting for background workers to finish.\\\")\\r\\n self._background_worker_pool.shutdown()\\r\\n self.report.end_workunit(self._background_root_workunit)\\r\\n self._background_root_workunit.end()\\r\\n\\r\\n if self._foreground_worker_pool:\\r\\n if self._aborted:\\r\\n self.log(Report.INFO, \\\"Aborting foreground workers.\\\")\\r\\n self._foreground_worker_pool.abort()\\r\\n else:\\r\\n self.log(Report.INFO, \\\"Waiting for foreground workers to finish.\\\")\\r\\n self._foreground_worker_pool.shutdown()\\r\\n\\r\\n self.report.end_workunit(self._main_root_workunit)\\r\\n self._main_root_workunit.end()\\r\\n\\r\\n outcome = self._main_root_workunit.outcome()\\r\\n if self._background_root_workunit:\\r\\n outcome = min(outcome, self._background_root_workunit.outcome())\\r\\n outcome_str = WorkUnit.outcome_string(outcome)\\r\\n log_level = WorkUnit.choose_for_outcome(outcome, Report.ERROR, Report.ERROR,\\r\\n Report.WARN, Report.INFO, Report.INFO)\\r\\n self.log(log_level, outcome_str)\\r\\n\\r\\n if self.run_info.get_info('outcome') is None:\\r\\n try:\\r\\n self.run_info.add_info('outcome', outcome_str)\\r\\n except IOError:\\r\\n pass # If the goal is clean-all then the run info dir no longer exists...\\r\\n\\r\\n self.report.close()\\r\\n self.upload_stats()\",\n \"def StartCombat(self):\\n\\n print(\\\"------------------------------------\\\")\\n self.fighter1.PrintInfo()\\n self.fighter2.PrintInfo()\\n print(\\\"------------------------------------\\\")\\n self.combatInProgress = True\\n while self.combatInProgress and self.currentTurn < self.maxTurns:\\n print(\\\"Turn {}:\\\".format(self.currentTurn))\\n self.CombatAttack()\\n if self.EndTurn():\\n print(\\\"------------------------------------\\\")\\n break\\n print(\\\"------------------------------------\\\")\\n time.sleep(3)\",\n \"def send_finish_event(self):\\n self.status['type'] = '__end__'\\n self._send()\",\n \"def end_game(self):\\n print(str(self.__players[0]._Player__name) + \\\" score is: \\\"\\n + str(self.__fields[0].score))\\n print(str(self.__players[1]._Player__name) + \\\" score is: \\\"\\n + str(self.__fields[1].score))\\n Game.play = False\",\n \"def finish(self) -> None:\",\n \"def finish(self) -> None:\",\n \"def onFinish(self):\\n self.finalizeStats()\",\n \"def run_combat(self, monster1, monster2):\\n\\n ce = combat_engine.CombatEngine(monster1, monster2, log_ref=self)\\n ce.run_combat()\",\n \"def finish_failed_goal(self, goal_handle, text=\\\"\\\"):\\n result = self.generate_grip_result(GripperResult.FAILURE)\\n self.finish_goal(goal_handle, result, text)\",\n \"def start_finish(self):\\r\\n self.send_queue.put(('finish',))\",\n \"def finish(self, success, msg=\\\"\\\"):\\n if success is True:\\n print(\\\"All sequences were downloaded correctly. Good!\\\")\\n if self.gui == 0:\\n sys.exit(\\\"Program finished without error.\\\")\\n else:\\n self.finished.emit(\\\"Download finished successfully!\\\")\\n raise ProgramDone\\n\\n else:\\n if self.gui == 0:\\n sys.exit(\\\"Program finished with some failures.\\\\n\\\" + msg)\\n else:\\n self.finished.emit(\\\"Program finished with some \\\"\\n \\\"failures.\\\\n\\\" + msg)\\n raise ProgramDone\",\n \"def finish_game(self) -> bool:\\n if not self.started and self.finished:\\n return\\n\\n self.started = False\\n self.finished = True\\n\\n players_list = self.games_list[self.game_index][\\\"players\\\"]\\n self.games_list[self.game_index][\\\"players\\\"] = \\\\\\n list(dict.fromkeys(players_list))\\n\\n return\",\n \"def finish(self):\",\n \"def finish(self):\",\n \"def end_game(self, winner):\\n reward = self.reward(winner)\\n if self.learning:\\n self.q_values[self.represent_state(self.prev_state), self.prev_action] += self.alpha * (\\n reward - self.prev_q_val)\\n self.log(\\\"the winner is {0}\\\".format(winner))\\n self.prev_state = None\\n self.prev_action = None\\n self.prev_q_val = 0\\n self.winner = VALUES.NOT_FINISHED\",\n \"def stand(self):\\n self.endgame()\",\n \"def finish_command(self):\\n if self.validate(False):\\n self.player_ships[self.values[0]] = self.values[1]\\n # Example Output:\\n # {'n': [[(0, 0), (1, 0), (2, 0), (3, 0)]],\\n # 'b': [[(1, 1), (2, 1), (3, 1), (4, 1)], [(2, 2), (2, 3), (2, 4)]]}\\n print(self.player_ships)\\n self.cancel()\",\n \"def Finish(self):\\n if self.verbose:\\n\\n print \\\"Finishing simulation\\\"\\n\\n for s in self._schedulees:\\n\\n s.Finish()\",\n \"def finish(self, result=CallResult.no_result):\\n assert not self.state is CallState.finished\\n\\n self.state = CallState.finished\\n self.finish_time = time()\\n self.result = result\",\n \"def end(self):\\n self.kill_flag.value = True\\n while (not self.pseye.thread_complete.value) or (not self.saver.saving_complete.value):\\n pass\",\n \"def onFinished( self, resultLine ):\\n\\t\\treturn self.agi.finish()\",\n \"def endEmpireTurn(self, myEmpire):\\n try:\\n # end the Empire's turn\\n myEmpire.endTurn()\\n \\n # check if all Empires turns are done\\n done = 1\\n for empireID, myEmpire in self.empires.iteritems():\\n if myEmpire.roundComplete == 0 and myEmpire.ai == 0:\\n done = 0\\n break\\n return done\\n except:\\n return 'galaxy->endEmpireTurn error'\",\n \"def end(self, text):\\n if text is None:\\n string = self._build_string(\\\"Completed!\\\")\\n else:\\n string = self._build_string(text)\\n out.write(\\\"\\\\r\\\" + string + \\\"\\\\n\\\")\\n out.flush()\",\n \"def finish(self):\\n if not self.finishTime:\\n self.stop()\\n report = [\\n \\\"flush script \\\" + str(self.runTime) + \\\" seconds\\\",\\n \\\"compute time \\\" + str(self.computeTime) + \\\" seconds\\\",\\n \\\"parse time \\\" + str(self.parseTime) + \\\" seconds\\\",\\n \\\"internal xfer time \\\" + str(self.transferTime) + \\\" seconds\\\",\\n \\\"output size \\\" + str(self.outputSize),\\n \\\"input size \\\" + str(self.inputSize),\\n \\\"intermediate size \\\" + str(self.intermedSize),\\n \\\"overall tree width \\\" + str(self.dagWidth),\\n \\\"local slots \\\" + str(self.task.config.execLocalSlots)]\\n joined = \\\"\\\\n\\\".join(report) \\n log.info(joined)\\n print joined\",\n \"def end(self):\\n self._log.debug('doing ..')\\n super().end()\\n\\n self._log.debug('done')\",\n \"def battle(hero, boss, spells, hard=False):\\n effects = {}\\n step = 0\\n while True:\\n # Run current after effects\\n for k,v in effects.items():\\n e = v[0]\\n e(hero, boss)\\n # print 'Running effect', e.func_name\\n del v[0]\\n if not v:\\n del effects[k]\\n\\n # print 'Step %d' % step\\n if step % 2 == 0:\\n if hard:\\n hero.hit -= 1\\n if hero.is_dead:\\n return 'lose'\\n\\n # Play magician\\n # No more spell ?\\n if step / 2 >= len(spells):\\n return 'moar'\\n\\n spell = spells[step/2]\\n\\n # no more mana ?\\n cost = all_spells[spell]\\n if hero.mana < cost:\\n return 'lose'\\n\\n # Check spell is not in effects\\n if spell in effects:\\n return 'invalid'\\n\\n # Run spell\\n # print 'Running', spell.func_name\\n # Remove mana used by spell\\n after = spell(hero, boss)\\n hero.mana -= cost\\n if after:\\n # Run first effect\\n after[0](hero, boss)\\n del after[0]\\n\\n # Save after effects\\n effects[spell] = after\\n\\n # print 'Hero -> %s' % boss\\n\\n else:\\n # Play boss\\n damage = max(1, boss.damage - hero.armor)\\n hero.hit -= damage\\n # print 'Boss -> %s' % hero\\n\\n # Win / lose ?\\n if hero.is_dead:\\n return 'lose'\\n if boss.is_dead:\\n return 'win'\\n\\n step += 1\",\n \"def end_conversation(self, fname=None):\\n if fname: self.save_conversation(fname)\\n self.current_summary = ''\\n self.current_persona = ''\\n self.current_img_path = ''\\n self.current_gender = ''\\n self.cached_query = ''\\n self.user_turns.clear()\\n self.gpt3_turns.clear()\",\n \"def end(self, win):\\n if win:\\n print('\\\\033[92m', \\\"task won.\\\", '\\\\033[0m')\\n if self._win_sound is not None:\\n self.sound_player.play(self._win_sound)\\n else:\\n print('\\\\033[91m', \\\"task lost\\\", '\\\\033[0m')\\n if self._loose_sound is not None:\\n self.sound_player.play(self._loose_sound)\\n if self._fulfill_if_lost:\\n self.force_fulfill()\\n\\n # removing the loose task\\n if self._loose_task is not None:\\n self.gameEngine.taskMgr.remove(self._loose_task)\\n if self._to_do_task is not None:\\n self.gameEngine.taskMgr.remove(self._to_do_task)\\n\\n # starting the next step\\n self.gameEngine.scenario.start_next_step()\",\n \"def finish_game(self, z):\\n for move in self.moves: # add this game winner result to all past moves.\\n move += [z]\",\n \"def fight(self, combat_item):\\r\\n if combat_item == self.weakness:\\r\\n print(\\\"You fend \\\" + self.name + \\\" off with the \\\" + combat_item )\\r\\n Character.victory_count +=1\\r\\n return True\\r\\n else:\\r\\n print(self.name + \\\" crushes you, puny adventurer\\\")\\r\\n return False\",\n \"def end():\\n return say()\",\n \"def end():\\n logging.info(\\\"Execution Ended\\\")\",\n \"def finish_subsystem(self):\\n self.__channel.close()\",\n \"def die(self):\\n\\t\\tself.game.end()\\n\\t\\tsuper(Ship, self).die()\",\n \"def Finish(self):\\n\\t\\n self.queue.join()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5964447","0.5951488","0.583827","0.58253044","0.57186526","0.569342","0.5643143","0.5618079","0.5599302","0.55874985","0.556114","0.5545428","0.5520197","0.5506429","0.5500326","0.5500326","0.5500326","0.5500326","0.54973876","0.5483571","0.5472781","0.5469753","0.54460603","0.5422016","0.5406112","0.5400281","0.5399097","0.53951055","0.53774154","0.53619623","0.53416425","0.5338766","0.5305661","0.5287949","0.5273912","0.5269473","0.52622426","0.52620596","0.52562916","0.5251223","0.5218964","0.51956266","0.5186779","0.5176045","0.5170932","0.51541895","0.5140788","0.51347995","0.51347995","0.51014525","0.5089851","0.5080468","0.5075028","0.5058339","0.5051024","0.50436693","0.50331146","0.5030035","0.50237185","0.5016996","0.5013386","0.5012071","0.50110453","0.5006669","0.50044876","0.50043684","0.5001849","0.49967355","0.49905232","0.49832323","0.49832323","0.4981165","0.4973689","0.49734643","0.4970103","0.49639717","0.49490324","0.4936684","0.4936684","0.49353528","0.49346262","0.49296752","0.4925225","0.49241036","0.49168506","0.49131823","0.49106458","0.49066272","0.49034697","0.48971996","0.48959777","0.48895147","0.48877516","0.48849264","0.4869342","0.4867719","0.48662242","0.48660815","0.48645273","0.48601228"],"string":"[\n \"0.5964447\",\n \"0.5951488\",\n \"0.583827\",\n \"0.58253044\",\n \"0.57186526\",\n \"0.569342\",\n \"0.5643143\",\n \"0.5618079\",\n \"0.5599302\",\n \"0.55874985\",\n \"0.556114\",\n \"0.5545428\",\n \"0.5520197\",\n \"0.5506429\",\n \"0.5500326\",\n \"0.5500326\",\n \"0.5500326\",\n \"0.5500326\",\n \"0.54973876\",\n \"0.5483571\",\n \"0.5472781\",\n \"0.5469753\",\n \"0.54460603\",\n \"0.5422016\",\n \"0.5406112\",\n \"0.5400281\",\n \"0.5399097\",\n \"0.53951055\",\n \"0.53774154\",\n \"0.53619623\",\n \"0.53416425\",\n \"0.5338766\",\n \"0.5305661\",\n \"0.5287949\",\n \"0.5273912\",\n \"0.5269473\",\n \"0.52622426\",\n \"0.52620596\",\n \"0.52562916\",\n \"0.5251223\",\n \"0.5218964\",\n \"0.51956266\",\n \"0.5186779\",\n \"0.5176045\",\n \"0.5170932\",\n \"0.51541895\",\n \"0.5140788\",\n \"0.51347995\",\n \"0.51347995\",\n \"0.51014525\",\n \"0.5089851\",\n \"0.5080468\",\n \"0.5075028\",\n \"0.5058339\",\n \"0.5051024\",\n \"0.50436693\",\n \"0.50331146\",\n \"0.5030035\",\n \"0.50237185\",\n \"0.5016996\",\n \"0.5013386\",\n \"0.5012071\",\n \"0.50110453\",\n \"0.5006669\",\n \"0.50044876\",\n \"0.50043684\",\n \"0.5001849\",\n \"0.49967355\",\n \"0.49905232\",\n \"0.49832323\",\n \"0.49832323\",\n \"0.4981165\",\n \"0.4973689\",\n \"0.49734643\",\n \"0.4970103\",\n \"0.49639717\",\n \"0.49490324\",\n \"0.4936684\",\n \"0.4936684\",\n \"0.49353528\",\n \"0.49346262\",\n \"0.49296752\",\n \"0.4925225\",\n \"0.49241036\",\n \"0.49168506\",\n \"0.49131823\",\n \"0.49106458\",\n \"0.49066272\",\n \"0.49034697\",\n \"0.48971996\",\n \"0.48959777\",\n \"0.48895147\",\n \"0.48877516\",\n \"0.48849264\",\n \"0.4869342\",\n \"0.4867719\",\n \"0.48662242\",\n \"0.48660815\",\n \"0.48645273\",\n \"0.48601228\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7119523"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76299,"cells":{"query":{"kind":"string","value":"to get the whole data in 'bus'"},"document":{"kind":"string","value":"def getList(self):\n nodeList = get_array(self.casenum, 'bus')\n self.nodeList = nodeList\n return nodeList"},"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_bus_details():\n\n\tbus_detail = db.session.query(Bus.bus_name == (Bus.bus_name)).one()\n\n \n\treturn bus_detail","def get_bus_list():\n\n\tbuses = db.session.query(Bus.bus_name).all()\n\n \n\treturn buses","def _read_data(self):","def readOneData(self):\n\t\tpass","def get_all(self):\n try:\n return self.current_data\n except:\n print('No data received from sensor')","def read(self):","def request_busG():\n busG = {}\n for x in G.nodes.items():\n if x[1].get('highway') == 'bus_stop':\n xy = []\n xy.append(x[1].get('osmid'))\n xy.append(x[1].get('x'))\n xy.append(x[1].get('y'))\n busG[x[1].get('osmid')] = xy\n\n return busG","def bus_dict(self):\n return self.__bus_dict","def read_serial_data(self):\n qdata = list(get_all_from_queue(self.data_q))\n if len(qdata) > 0:\n data = self.data+''.join(qdata)\n while data.find(\"Id: \")!=-1:\n msgStart = data.find(\"Id: \")\n msgEnd = data.find(\"\\n\",msgStart)\n if msgEnd == -1:\n break\n\n packet = data[msgStart:msgEnd-1]\n # print \"msg: [%s]\" % packet\n msgId = int(packet[4:8],16)\n # print \"msgId: %d [%x]\" % (msgId, msgId)\n msgData = map(lambda x: int(x,16) ,packet[16:].split(\" \"))\n # print \"data: \", msgData\n self.update_data(msgId, msgData)\n\n data = data[msgEnd:]\n self.data = data","def get_data(self):\n return read_sensor(bus=self.bus,\n address=self.address)","def get_data(self):","def read(self):\n temp = self.bus.read_i2c_block_data(self.address, 0)\n print('temp', temp)\n return_buffer = []\n for i in temp:\n return_buffer += str(chr(int(i)))\n\n return return_buffer","def registers(self):\n data = int(0)\n # length = data.from_bytes(self.length, 'big')\n length = len(self.contents)\n print(\"recv data length is {}\".format(length))\n format = '!%dH'% (length/2)\n # print(len(self.contents))\n registers_data = struct.unpack(format, self.contents)\n\n return list(registers_data)","def data(self):","def get_bus_location():\n\n transit_data = cache.get(\"transit_data\")\n if transit_data:\n return transit_data\n \n routes = get_routes()\n\n live_data_url = \"http://gtfs.edmonton.ca/TMGTFSRealTimeWebService/Vehicle/VehiclePositions.pb\"\n feed = gtfs_realtime_pb2.FeedMessage()\n live_data_response = requests.get(live_data_url)\n feed.ParseFromString(live_data_response.content)\n\n transit_data = {} # contains the informtion for all the busses\n for entity in feed.entity:\n if entity.HasField(\"vehicle\"):\n trip_number = entity.vehicle.trip.trip_id\n # sometimes the live bus trip ids don't show up in the routes database\n if trip_number not in routes:\n continue\n\n bus_number, bus_title = routes[trip_number]\n vehicle = entity.vehicle.vehicle.id\n \n # the higher one seems to be correct - sometimes the vehicle id is too short\n if entity.vehicle.vehicle.label:\n vehicle = max(int(entity.vehicle.vehicle.id),\n int(entity.vehicle.vehicle.label))\n latitude = entity.vehicle.position.latitude\n longitude = entity.vehicle.position.longitude\n bearing = entity.vehicle.position.bearing\n\n vehicle_data = {\"bus_number\": bus_number,\n \"bus_title\": bus_title,\n \"latitude\": latitude,\n \"longitude\": longitude,\n \"bearing\": bearing,\n \"trip_id\": trip_number}\n\n transit_data[vehicle] = vehicle_data\n \n cache.set(\"transit_data\", transit_data, timeout=15)\n return(transit_data)","def get_data(self):\n self._send_command(self._adapter.get_data())","def get_bus(self):\n return self._bus","def _get_data(self):\n c = Connector(self.host, self.username, self.password)\n return c.getLanDevices()","def collect_data():\n\n \"Aqui va el codigo de alberto para recoger los datos que puede venir en forma de diccionario\"\n #TODO: Función para recoger los datos de los bms y meterlos en diccionarios (Alberto jr.)\n\n bms1 = dict()\n bms2 = dict()\n bms3 = dict()\n general = dict()\n\n\n # Ejemplos de datos para meter en los diccionarios\n\n temperature = 35.5\n voltage1 = 15.2\n voltage2 = 14.8\n date = time.strftime(\"%Y-%m-%d\") # Current date\n t = time.strftime(\"%H:%M:%S\") # Current time\n\n return bms1, bms2, bms3, general","def _wbt_read_data(self):\n\t\treaData = True\n\t\twbtIncomingData = False\n\t\twbtData = \"\"\n\t\twhile reaData:\n\t\t\twbtIncomingMsg = self._webots.stdout.readline().rstrip(\"\\n\").split()\n\t\t\tif \"COMM_OUT\" in wbtIncomingMsg: wbtIncomingData = True\n\t\t\telif \"END\" in wbtIncomingMsg: reaData = False\n\t\t\telif wbtIncomingData: wbtData += \" \".join(wbtIncomingMsg[1:])+\"\\n\"\n\t\t\tprint \"\\t\\t\\t\\tWebots: :\"+\" \".join(wbtIncomingMsg[1:])\n\t\treturn wbtData","def get_data(self):\n self.dev.write(1, 'A0')\n digit1, digit2 = self.dev.read(0x81, 64)[:2]\n # Save the data as voltage between 0.0 and 5.0\n self.data0.append((digit1 + 256*digit2)*5.0/1024)","def query(self):\n self.bus.write('@\\x51\\r\\n')\n response = self.bus.read(23)\n return response","def testAllRead(self):\n import time,copy\n time.sleep(2)\n client = ModbusTCP(self.config['vdevs']['slave']['icsifaces'][0],\n self.config['vdevs']['slave']['points']) \n\n pts = copy.deepcopy(self.config['vdevs']['slave']['points'])\n ptnames = [ pt['name'] for pt in pts ]\n reply = client.readPoints(ptnames)\n #print \"Reply: \", reply\n for pt in ptnames:\n value = filter(lambda x: x['name']==pt, pts)[0]['value']\n #assert value == reply[ptnames.index(pt)]\n received = reply[ptnames.index(pt)]\n if not value == received: \n print pt, ' was %s but should be %s'%(str(received),str(value))","def s_read(self, timeout = 1):\n if self.s.is_open:\n data = [] \n b = bytearray()\n try:\n self.s.timeout = 3\n data = self.s.read(1)\n \n if not len(data):\n return b\n\n self.s.timeout = .04\n data += self.s.read(500)\n except Exception as e:\n print(\"Could not read from port\" + str(e))\n\n start = data.find(b'\\x7e')\n end = data.find(b'\\x7f')\n\n txt_start = b''\n txt_end = b''\n if start < 0:\n txt_start = data\n elif end < 0:\n txt_start = data\n else:\n txt_start = data[0:start]\n txt_end = data[end+1:]\n\n txt = txt_start + txt_end\n if len(txt):\n if self.log_ascii:\n self.logfile.write(txt)\n\n # End logging \n if Connection.START_UP_STRING in data:\n raise Reset_Exception('ChipSHOUTER unit has reset - wait 5 seconds then reinitialize.') \n\n if start < 0 or end < 0 or end < start:\n b = bytearray()\n return b\n if self.log_input:\n self.logfile.write('\\nIN :' + str(len(data)) + '[' + hexlify(data) + ']' + '\\n')\n b.extend(data[start:end])\n return b\n else:\n raise IOError('Comport is not open, use ctl_connect()')","def get_data(self):\n self._zmq_request.send(b'next')\n return msgpack.loads(self._zmq_request.recv())","def get_cmdb_data(device_type):\n pass","def read_drt(self):\n data = Array('B')\n data = self.read(0, 0, 8)\n num_of_devices = drt_controller.get_number_of_devices(data)\n len_to_read = num_of_devices * 8\n\n data = self.read(0, 0, len_to_read + 8)\n self.drt_manager.set_drt(data)","def recive_data(self, socket_cliente):\n # Protocolo de informacion\n data = bytearray()\n bytes_largo = socket_cliente.recv(4)\n largo_bytes = int.from_bytes(bytes_largo, byteorder=\"big\")\n numero_chunks = (largo_bytes // 60) + 1\n for i in range(numero_chunks):\n numero_bloque = socket_cliente.recv(4)\n data_bloque = socket_cliente.recv(60)\n if i == (numero_chunks - 1):\n data_bloque = data_bloque[0: (largo_bytes % 60)]\n data.extend(data_bloque)\n\n if data == \"\":\n pass\n else:\n return data","def get_readings(self):\n buf = self._read(0x020001)\n data = decode(buf[1:])\n return data","def get_data():\n pass","def get_nmea_data(port):\n \n# q = 1 # quality factor\n \n # Wait for RMC message :\n rmc = port.readline().decode(\"utf-8\")\n while not 'RMC' in rmc:\n if rmc: \n print(\"Wait for RMC : \", rmc)\n rmc = port.readline().decode(\"utf-8\")\n\n \n # Read GGA+GST+ZDA messages :\n gga = port.readline().decode(\"utf-8\")\n gst = port.readline().decode(\"utf-8\")\n zda = port.readline().decode(\"utf-8\")\n \n t = np.float(gga[7:16])\n \n # Print messages :\n print(\"Trames :\")\n print(\" RMC: \",rmc)\n print(\" GGA: \",gga)\n print(\" GST: \",gst)\n print(\" ZDA: \",zda)\n \n # Quality check :\n if not 'GGA' in gga or not 'GST' in gst or not 'ZDA' in zda:\n print(\"Issue with GGA/GST/ZDA frame decoding !\\nMessage:\\nGGA:{0}\\nGST:{1}\\nZDA:{2}\".format(gga, gst, zda))\n rmc, gga, gst, zda, t = get_nmea_data(port)\n \n return rmc, gga, gst, zda, t","def get_data(self):\r\n pass","def readData(self):\n if (self.model == 'GDS'):\n self.write(':ACQ'+str(ch)+':MEM?\\n')\n elif (self.model == 'TDS'):\n self.write('CURVe?\\n')\n\n # Check for the initial '#'; if not present, raise error.\n if (self.read(1) != '#'):\n raise Exception, \"Expected header not present\"\n\n # Read the data length indicator\n dataSize = int(self.read(int(self.read(1))))\n\n # extra steps for GDS\n if (self.model == 'GDS'):\n # subtract the 8 bytes we will read.\n dataSize -= 8\n # Read the sampling period\n hstep = struct.unpack('>f', self.read(4))[0]\n # also, fix hoff so it corresponds with that for TDS\n # FIXME: check with the scope at some point.\n hoff = hoff - float(dataSize/4) * hstep\n # Read 4 bytes to advance to the actual data: first byte\n # contains the channel and the three are not used,\n # according to the GDS800 manual.\n self.read(4)\n \n # Read data; TDS expects a 1-byte data, GDS expects 2-byte one.\n if (self.model == 'TDS'):\n data = list(struct.unpack('>'+str(dataSize)+'b',\n self.read(dataSize)))\n # TDS has a trailing '\\n' that should be drained.\n self.read(1)\n elif (self.model == 'GDS'):\n data = list(struct.unpack('>'+str(dataSize/2)+'h',\n self.read(dataSize)))\n\n return data","def bus_func(self, bus):\n return 0","def _do_get_values(self, args):\r\n bus_type = args[1]\r\n slave_id = int(args[2])\r\n name = args[3]\r\n address = int(args[4])\r\n length = int(args[5])\r\n if bus_type == 'rtu':\r\n slave = self.server._servers[0].get_slave(slave_id)\r\n elif bus_type == 'tcp':\r\n slave = self.server._servers[1].get_slave(slave_id)\r\n values = slave.get_values(name, address, length)\r\n return self._tuple_to_str(values)","def get_data(self):\n data = {\n \"ts\": self.drone.pos[0][0],\n \"drone\": self.drone,\n \"subject\": self.subject,\n \"peds\": self.peds, # can be None\n \"objs\": self.objs # can be None\n }\n self.empty_bag()\n return data","def read():\n # TODO","def testAllRead(self):\n import time,copy\n time.sleep(2)\n to_config = self.config['vdevs']['slave']['icsifaces'][0]\n from_config = self.config['vdevs']['master']['clientifaces'][0]\n points = self.config['vdevs']['slave']['points']\n client = ModbusRTU(to_config, points, from_config)\n\n\n pts = copy.deepcopy(self.config['vdevs']['slave']['points'])\n for i in xrange(50):\n ptnames = [ pt['name'] for pt in pts ]\n reply = client.readPoints(ptnames)\n #print \"Reply: \", reply\n for pt in ptnames:\n value = filter(lambda x: x['name']==pt, pts)[0]['value']\n #assert value == reply[ptnames.index(pt)]\n received = reply[ptnames.index(pt)]\n if not value == received: \n print pt, ' was %s but should be %s'%(str(received),str(value))","def next_bus(stop_point):\n stop = str(stop_point)\n r = requests.get('https://api-radon.tfl.gov.uk/StopPoint/' + stop_point + '/Arrivals')\n print(r)\n json_result = r.json()\n all_stops = json_result\n my_buses = []\n for i in all_stops:\n i = '{}, {}-min'.format(str(i['destinationName']),str(round(i['timeToStation']/60)))\n my_buses.append(i)\n return my_buses","def servo_read_all(self):\n msg = b'\\x25\\x00'\n parameter_len = 16\n ans = self.__bt.read(msg, parameter_len)\n if ans is not None:\n return [x for x in ans]\n return None","def getData(self):\n self.ser.write(b'g')\n readString = self.ser.readline()\n print(readString)\n readString = readString.decode(\"utf-8\")\n splittedString = readString.split('\\t')\n for i, num in enumerate(splittedString):\n try:\n splittedString[i] = int(float(num))\n except ValueError:\n pass\n self.accString.set('Accleration\\nX: %.5f\\nY: %.5f\\nZ: %.5f' %\n (splittedString[0], splittedString[1],\n splittedString[2]))\n self.logFile.write(readString)\n self.comJob = root.after(10, self.getData)","def get_station_boroughs(self):\\","def read(self):\n \n #self.lego_bus.write_byte(self.address, 0xF5)\n #time.sleep(0.2)\n block=0\n rawhumidity=0\n counter=0\n toRead=0\n while counter < 10 and toRead != 3:\n self.lego_bus.write_byte(self.address, 0xFE)\n self.lego_bus.write_byte(self.address, 0xF5)\n sleep(1)\n \n try:\n block = self.lego_bus.read_i2c_block_data(self.address, 0, 3)\n print (block)\n rawhumidity = (( block[0] << 8) | block[1])\n print (rawhumidity)\n except:\n print(\"Error inesperado:\", sys.exc_info()[0])\n counter +=1\n \n\n rh=999 # if invalid checksum return error value\n if (self.check_crc(rawhumidity, block[2]) == 0): #Verify the checksum \n #rawhumidity &= 0xFFFC\n print (rawhumidity)\n tempRH = rawhumidity / 65536.0\n rh = -6.0 + (125.0 * tempRH)\n return rh","def get_data(self):\n pass","def get_data(self):\n pass","def read_buffer(serial):\r\n resp = serial.read_all()\r\n return resp.decode()","def getAll(self):\n return self.dataBuffer","def getData(self,cmd):\n self.ser.write(cmd.encode()+END.encode())\n out = self.ser.readline()\n\n if(out == \"\"):\n raise IOError(\"communication failed\")\n return out","def recibir(self):\r\n lenbuf = self.__recvall(4)\r\n longitud, = struct.unpack('!I', lenbuf)\r\n return self.__recvall(longitud)","def sample(self):\n print(\"sampling bluetooth arduino\")\n self.sock.send(b'B')\n data = b''\n '''while True:\n data += self.sock.recv(1024)\n if data.endswith(b'\\n'):\n break\n '''\n #self.sock.settimeout(2)\n try:\n while True:\n d = self.sock.recv(255)\n data += d\n if d.find(b'\\n') != -1:\n break\n except Exception as err:\n print(err)\n pass\n print(data)\n data = json.loads(data.decode())\n if not any(x == 0 for x in data.values()):\n for label in self.data_labels:\n self.data[label].append(data[label])\n #self.data[\"time\"].append(time.time() - self.start)\n print(data)\n #print(self.data)\n #return self.data","def read_holding_registers(self, unit, address, length):\r\n # generate jbus request \r\n request = Request(function_code=3, unit=unit, address=address, length=length)\r\n \r\n _logger.debug(\"Request is {}\".format(request.bytes))\r\n\r\n # generate jbus response\r\n response = self.transition.execute(request)\r\n return response","def get_all_data(self):\n\t\treply = self._send_command_to_entity_server(us.SERVER_COMMAND_REQUEST_ALL_DATA)\n\t\t#print(reply)\n\t\treturn reply","def read(self):\n try:\n cmd = 'SAMP:COUN 1' \n self.handle.write(cmd) #one sample per trigger\n self.handle.write('TRIG:SOUR BUS') #triggered by command\n self.handle.write('TRIG:COUN 1') #one trigger to return to wait for trg\n self.handle.write('INIT:IMM') #DVM to \"wait for trigger\" \n self.handle.write('*TRG')\n startTime = time.time()\n while True: #wait until measuring flag goes to 0\n try:\n measured = self.handle.ask(\"DATA:POIN?\")\n measured = measured.strip() #remove CR \n measured = int(measured) #convert to number\n if measured == 1: #final number of samples achieved\n break;\n except Exception:\n print('Dvm34411:read() polling failed !')\n raise\n \n if time.time() - startTime > self.timeout:\n print('Dvm34411:read() timeout !')\n return False\n \n time.sleep(1) \n reading = self.handle.ask('R? 1;') #definite-Length block format\n except Exception:\n print('Dvm34411.read() failed !')\n raise\n if reading[0] != '#':\n print('Dvm34411.read() DLB format error - # expected !')\n return False\n digits = int(reading[1])\n reading = reading[2 + digits:]\n rdg = float(reading)\n return rdg","def _read(self, register):\n\n addr, num_bytes = register\n data = response = error = None\n if num_bytes == 1:\n data, response, error = self.packet_handler.read1ByteTxRx(\n self.port_handler, self._id, addr\n )\n elif num_bytes == 2:\n data, response, error = self.packet_handler.read2ByteTxRx(\n self.port_handler, self._id, addr\n )\n else:\n data, response, error = self.packet_handler.read4ByteTxRx(\n self.port_handler, self._id, addr\n )\n\n # Check response\n self._error_handler(response, error)\n\n return data","def _usb_get_report(self):\n arraydata=self.usbdev.ctrl_transfer(bmRequestType=0xa1, bRequest=0x01, wValue=0x03b0, wIndex=0, data_or_wLength=9)\n data=arraydata.tolist()\n assert (data[0:4]==[0xb0,0x00,0x00,0x01]) or \\\n (data[0:4]==[0xb0,0xaa,0x00,0x01]) or \\\n (data[0:4]==[0xb0,0xaa,0x00,0x00]), \\\n 'unexpected device status info start: %s'%(data[0:4])\n assert data[8]==1,'unexpected last byte value: %s'%data[8]\n position=data[4:6]\n v_pos=data[6]\n self.vertical_position=v2k(v_pos,V_POS)\n self.intensity=data[7]\n self.position=v2k(position,POSITION)\n return(data)","def get_data():\n return","def parse(self):\n i = 1\n times = []\n while 1:\n byte = yield\n if byte== 0xaa:\n byte = yield # This byte should be \"\\aa\" too\n if byte== 0xaa:\n # packet synced by 0xaa 0xaa\n packet_length = yield\n packet_code = yield\n if packet_code == 0xd4:\n # standing by\n self.state = \"standby\"\n elif packet_code == 0xd0:\n self.state = \"connected\"\n elif packet_code == 0xd2:\n data_len = yield\n headset_id = yield\n headset_id += yield\n self.dongle_state = \"disconnected\"\n else:\n self.sending_data = True\n left = packet_length - 2\n while left>0:\n if packet_code ==0x80: # raw value\n row_length = yield\n a = yield\n b = yield\n value = struct.unpack(\"<h\",chr(b)+chr(a))[0]\n self.dispatch_data(\"raw\", value)\n left -= 2\n elif packet_code == 0x02: # Poor signal\n a = yield\n\n left -= 1\n elif packet_code == 0x04: # Attention (eSense)\n a = yield\n if a>0:\n v = struct.unpack(\"b\",chr(a))[0]\n if 0 < v <= 100:\n self.dispatch_data(\"attention\", v)\n left-=1\n elif packet_code == 0x05: # Meditation (eSense)\n a = yield\n if a>0:\n v = struct.unpack(\"b\",chr(a))[0]\n if 0 < v <= 100:\n self.dispatch_data(\"meditation\", v)\n left-=1\n elif packet_code == 0x16: # Blink Strength\n self.current_blink_strength = yield\n \n left-=1\n elif packet_code == 0x83:\n vlength = yield\n self.current_vector = []\n for row in range(8):\n a = yield\n b = yield\n c = yield\n value = a*255*255+b*255+c\n left -= vlength\n self.dispatch_data(\"bands\", self.current_vector)\n packet_code = yield\n else:\n pass # sync failed\n else:\n pass # sync failed","def __get_data(self):\n ips = self.server.JUGADORES.keys()\n convida = list(ips)\n retorno = \"\"\n for ip in ips:\n nick = self.server.JUGADORES[ip]['nick']\n tanque = self.server.JUGADORES[ip]['path']\n energia = self.server.JUGADORES[ip]['energia']\n vidas = self.server.JUGADORES[ip]['vidas']\n puntos = self.server.JUGADORES[ip]['puntos']\n posicion = self.server.JUGADORES[ip]['pos']\n bala = self.server.JUGADORES[ip]['bala']\n\n datos = \"%s,%s,%s,%s,%s,%s,%s,%s\" % (ip, nick, tanque,\n posicion, vidas, energia, puntos, bala)\n\n explosion = self.server.JUGADORES[ip]['explosiones'].get(\n self.client_address[0], False)\n if explosion:\n datos = \"%s,%s\" % (datos, explosion)\n del(self.server.JUGADORES[ip][\n 'explosiones'][self.client_address[0]])\n\n retorno = \"%s%s||\" % (retorno, datos)\n if vidas == 0:\n convida.remove(ip)\n\n if len(ips) > 1 and len(convida) == 1:\n return \"END\"\n else:\n return retorno.strip()","def read_data(self):\n raise NotImplementedError","def read(self, reg):\n return self.bus.read_byte_data(self.address, reg)","def get_data(self):\n if self.ser.in_waiting:\n data_string = self.ser.readline().decode().strip()\n if not data_string: return self.data\n self.data = [\n float(element) for element in data_string.split()\n ]\n self.ser.reset_input_buffer()\n return self.data","def getData(self):\n return struct.unpack(\"!Q\",self.data)[0]","def getData(self):\n return struct.unpack(\"!Q\",self.data)[0]","def getAllData(self):\r\n return self.data","def getData(self):\n data = self.rx.getNData()\n\n return (data)","def read_from_serial(self):\n output = b''\n time.sleep(self._sleep_time)\n while self._ser.inWaiting() > 0:\n output = output + self._ser.read(1)\n #A default ten powercycle delay means that some measurements may still be processing\n #by the time the read function is called. This slows down the read but ensures that\n #it will finish (per my testing). There is probably a better way to do this. TODO\n time.sleep(0.06)\n return output.decode('utf-8').strip()","def achieve_data(self, selection='all'):\r\n Infra_Omi, Infra_L, Infra_R = None, None,None\r\n bump, L_cnt, R_cnt, DLightBump, AnalogBump = None,None,None,None,None\r\n if selection == 'b':\r\n # read bumper data only\r\n Infra_Omi,Infra_L, Infra_R, bump,DLightBump, L, FL, CL, CR, FR, R = self.Roomba.ReadQueryStream(17,52,53, 7,45, 46, 47,48, 49, 50, 51)\r\n AnalogBump = (L, FL, CL, CR, FR, R)\r\n elif selection == 'e':\r\n # read encoder data only\r\n L_cnt, R_cnt= self.Roomba.ReadQueryStream( 43, 44)\r\n else:\r\n # read all data\r\n Infra_Omi, Infra_L, Infra_R,bump, L_cnt,R_cnt, DLightBump, L,FL, CL,CR,FR,R =self.Roomba.ReadQueryStream(17,52,53,7, 43, 44, 45, 46,47,48,49,50,51 )\r\n AnalogBump = (L,FL, CL,CR,FR,R)\r\n\r\n return L_cnt,R_cnt, bump, DLightBump,AnalogBump,Infra_Omi, Infra_L, Infra_R","def receive_data(self, conn):\n data = conn.recv(2048)\n message = data.decode('utf-8')\n currDev = ''\n if message != self.last_message and message != '':\n if len(message) >= 24:\n for letter in message:\n currDev += letter\n if len(currDev) == 12:\n self.list_of_devices += [currDev]\n currDev = ''\n else:\n self.list_of_devices = [message]\n\n print(self.list_of_devices)","def read_data(self):\n temperature_data = RS485.read_temperature(self.data_path)\n humidity_data = RS485.read_humidity(self.data_path)\n moisture_data = RH_010_GN.read_moisture(self.data_path)\n o2_data = LB_856.read_o2(self.data_path)\n co2_data = LB_856.read_co2(self.data_path)\n\n self.data = [temperature_data, humidity_data, moisture_data, o2_data, co2_data]","def data(self):\n pass","def data(self):\n pass","def GetData(self):\r\n \r\n return self._data","def get_data(self):\n try:\n data_string = self.ser.readline().decode()\n except UnicodeDecodeError as e:\n return self.get_data()\n \n if not data_string: # check for empty string\n return self.get_data()\n \n if data_string[0] == '|' and data_string[-1] == '\\n' and\\\n self.reset_confirmed:\n # if the data_string is valid, process it\n try:\n data_string = data_string.strip() \n data = data_string.split(',')\n assert len(data) == 7, \"Bad data Length\" \n data = [float(val) for val in data[1:]]\n data[0] /= 1000\n if self.ser.in_waiting: self.ser.reset_input_buffer()\n return data\n except (AssertionError, ValueError) as e:\n print(\"Error:\", type(e), e)\n if self.ser.in_waiting: self.ser.reset_input_buffer()\n return self.get_data()\n\n\n elif data_string[0] == '+' and data_string[-1] == '\\n' and\\\n self.reset_confirmed:\n # if the data_string is a valid time stamp, process it\n # self.system_timestamp = \"\\nSystem start time is: \"\\\n # \"%s\" % strftime(\"%Y/%m/%d %H:%M:%S\", localtime())\n self.arduino_timestamp = data_string.strip()\n print(self.arduino_timestamp)\n return self.get_data()\n \n elif data_string[0] == '/' and data_string[-1] == '\\n':\n # if string begins with / then it is a debug message and should\n # just be returned\n if \"setup finished\" in data_string.lower(): \n self.reset_confirmed = True\n print(data_string.strip())\n return self.get_data()\n else:\n # if the data_string is invalid try again\n return self.get_data()","def _read_multiple_bytes_as_array(self, reg_addr, lenght):\n return self.bus.read_i2c_block_data(self.I2C_ADDRESS, reg_addr, lenght)","def get(self):\n try:\n log.debug(\"Device info : \")\n #get the payload to influx DB\n url = \"http://localhost:8086/query\"\n querystring = {\"pretty\": \"true\", \"db\": \"IOT\",\n \"q\":\"SELECT DISTINCT(deviceId) FROM(SELECT deviceId,q1 FROM \\\"ttd_devices\\\" ) \" }\n response = requests.request(\"GET\", url, params=querystring)\n r_d=json.loads(response.text)\n result_d=[]\n for rec in r_d['results'][0]['series']:\n for element in rec['values']:\n result_d.append(element[1])\n result={}\n result['status'] = 1\n result['message']=result_d\n return_status = 200\n except ValueError as e:\n result = {}\n log.exception('Value Exception while fetching device list')\n result['status'] = 0\n return_status = 400\n result['message'] = e.args[0]\n except :\n result = {}\n log.exception('Exception while fetching the device data')\n return_status = 500\n result['status'] = 0\n result['message'] = 'Internal Error has occurred while fetching devie data'\n finally:\n resp = Response(json.dumps(result), status=return_status, mimetype=\"application/json\")\n return resp","def read(self):\n pass","def get_data(self):\n return {\n \"fd\": self.get_fd_j(self.id),\n \"fd_part\": self.get_fd_part_j(self.id),\n \"config\": self.config,\n # \"config\": self.get_config_j(self.id),\n \"prp\": self.get_prp_j(self.id),\n \"alll\": self.my_alll(self.id)\n }","def _get_data(self):\n devices = []\n try:\n if not self.router_client.login():\n self.hass.states.set(f\"{DOMAIN}.statusmsg\", self.router_client.statusmsg)\n _LOGGER.warning(\"Login failed: {0}:{1}@{2}\".format(self.router_client.username, self.router_client.password,self.router_client.host))\n self.router_client.logout()\n return devices\n\n devices_json = self.router_client.get_devices_response()\n finally:\n self.router_client.logout()\n\n self.hass.states.set(f\"{DOMAIN}.scanning\", devices_json != False)\n\n if devices_json != False:\n for device in devices_json:\n # _LOGGER.debug(\"Device: {0}\".format(device))\n dev = Device(\n device['HostName'].replace('未知设备', 'Unknown'),\n device['IPAddress'],\n device['MACAddress'],\n device['Active'],\n ICONS.get(device['IconType'])\n )\n # _LOGGER.debug(\"Device: {0}\".format(dev))\n devices.append(dev)\n return devices\n else:\n return []","def get(self):\r\n return self.data_array","def get_array(self):\r\n samples = getattr(self.instrument, self.devchan+'_samples')()\r\n sample_rate = getattr(self.instrument, self.devchan+'_sample_rate')()\r\n timeout = getattr(self.instrument, self.devchan+'_timeout')()\r\n return self.instrument.read_analog(self.devchan,\r\n samples,\r\n sample_rate,\r\n timeout,\r\n self.chan_config,\r\n self.minv,\r\n self.maxv,\r\n self.triggered,\r\n False\r\n )","async def get_api_data(self) -> dict:\n if not self.bos.is_set():\n self.lit = False\n return self.messages\n try:\n # get all data and split it up\n all_data = await self.send_api_cmd(\"devs+temps+fans\")\n devs_raw = all_data['devs'][0]\n temps_raw = all_data['temps'][0]\n fans_raw = all_data['fans'][0]\n\n # parse temperature data\n temps_data = {}\n for board in range(len(temps_raw['TEMPS'])):\n temps_data[f\"board_{temps_raw['TEMPS'][board]['ID']}\"] = {}\n temps_data[f\"board_{temps_raw['TEMPS'][board]['ID']}\"][\"Board\"] = temps_raw['TEMPS'][board]['Board']\n temps_data[f\"board_{temps_raw['TEMPS'][board]['ID']}\"][\"Chip\"] = temps_raw['TEMPS'][board]['Chip']\n\n # parse individual board and chip temperature data\n for board in temps_data.keys():\n if \"Board\" not in temps_data[board].keys():\n temps_data[board][\"Board\"] = 0\n if \"Chip\" not in temps_data[board].keys():\n temps_data[board][\"Chip\"] = 0\n\n # parse hashrate data\n hr_data = {}\n for board in range(len(devs_raw['DEVS'])):\n hr_data[f\"board_{devs_raw['DEVS'][board]['ID']}\"] = {}\n hr_data[f\"board_{devs_raw['DEVS'][board]['ID']}\"][\"HR\"] = round(\n devs_raw['DEVS'][board]['MHS 5s'] / 1000000,\n 2)\n\n # parse fan data\n fans_data = {}\n for fan in range(len(fans_raw['FANS'])):\n fans_data[f\"fan_{fans_raw['FANS'][fan]['ID']}\"] = {}\n fans_data[f\"fan_{fans_raw['FANS'][fan]['ID']}\"]['RPM'] = fans_raw['FANS'][fan]['RPM']\n\n # set the miner data\n miner_data = {'IP': self.ip, \"Light\": \"show\", 'Fans': fans_data, 'HR': hr_data, 'Temps': temps_data}\n\n # save stats for later\n self.stats = miner_data\n\n # return stats\n return miner_data\n except:\n # if it fails, return install data\n # usually fails on getting None from API\n self.lit = False\n data = self.messages\n data['Light'] = \"show\"\n return data","def get_scan_data(self):\n return self.scan_data","def transmissionData(self, port='Substrate_bottom'):\n\n data = self.data['fluxes']\n # sorted_layers is an OrderedDict, and thus has the popitem method\n sorted_layers = self.conf.sorted_dict(self.conf['Layers'])\n # self.log.info('SORTED LAYERS: %s', str(sorted_layers))\n first_layer = sorted_layers.popitem(last=False)\n self.log.info('FIRST LAYER: %s', str(first_layer))\n # An ordered dict is actually just a list of tuples so we can access\n # the key directly like so\n first_name = first_layer[0]\n bfirst_name = first_name.encode('utf-8')\n self.log.info('FIRST LAYER NAME: %s', str(first_name))\n bport = port.encode('utf-8')\n # p_inc = data[first_name][0]\n # p_ref = np.abs(data[first_name][1])\n # p_trans = data[last_name][0]\n p_inc = np.absolute(data[data.layer == bfirst_name][0][1])\n p_ref = np.absolute(data[data.layer == bfirst_name][0][2])\n p_trans = np.absolute(data[data.layer == bport][0][1])\n reflectance = p_ref / p_inc\n transmission = p_trans / p_inc\n absorbance = 1 - reflectance - transmission\n tot = reflectance + transmission + absorbance\n delta = np.abs(tot - 1)\n self.log.info('Reflectance %f' % reflectance)\n self.log.info('Transmission %f' % transmission)\n self.log.info('Absorbance %f' % absorbance)\n self.log.info('Total = %f' % tot)\n assert(reflectance >= 0)\n assert(transmission >= 0)\n assert(absorbance >= 0)\n # assert(delta < .00001)\n # Try to get a prexisting array if it exists\n try:\n # If array has been computed before get it\n arr = self.data['transmission_data']\n # If we already have data at this port update that row, otherwise\n # resize the array to accomodate the new row and insert the data\n ind = np.where(arr.port == port.encode('utf-8'))[0]\n if len(ind) > 0:\n arr[ind[0]] = (port, reflectance, transmission, absorbance)\n else:\n arr = np.resize(arr, arr.shape[0]+1)\n arr[-1] = (port, reflectance, transmission, absorbance)\n except:\n # Otherwise we need to make a new one\n dt = [('port', 'S25'), ('reflection', 'f8'),\n ('transmission', 'f8'), ('absorption', 'f8')]\n arr = np.recarray((1,), dtype=dt)\n arr[-1] = (port, reflectance, transmission, absorbance)\n self.data['transmission_data'] = arr\n return reflectance, transmission, absorbance","def get_data(self): # TODO: add smooth possibility\n return self.data","def getData(self):\n return self.data","def getData(self):\n return self.data","def read(self):\n try:\n datos = self.base.readData()\n for i in range(len(datos)):\n self.verDatos.insert('', i+1, text = i+1, values = (datos[i][0], datos[i][1], datos[i][2]))\n except:\n showerror(\"Error\", exc_info()[1])","def _get_data_from_send_queue(self):\n size = self.send_queue.qsize()\n if size > 1:\n data = b''.join([self.send_queue.get() for _ in range(size)])\n else:\n data = self.send_queue.get()\n return data","def get_data ( self ):\n return self._data_pntr.ReadAsArray()","def get_data ( self ):\n return self._data_pntr.ReadAsArray()","def __init__(self, bus: int, /):","def recive_data(self):\n # read all available data\n while self.ser.inWaiting() > self.INPUT_DATA_SIZE+1:\n data = array.array('c')\n # search the header\n data.append(self.ser.read(1))\n while data[0] != chr(1):\n data[0] = self.ser.read(1)\n \n # wait for all available data\n while self.ser.inWaiting() < (self.INPUT_DATA_SIZE-1):\n time.sleep(0.03);\n \n # recives data\n data = self.ser.read(self.INPUT_DATA_SIZE-1)\n \n # prove if you want graphical data\n if self.pushButton_monitor.isChecked():\n # decodes the data\n t = struct.unpack('I', data[3]+data[2]+data[1]+data[0])\n r = struct.unpack('f', data[4]+data[5]+data[6]+data[7])\n x0 = struct.unpack('f', data[8]+data[9]+data[10]+data[11])\n x1 = struct.unpack('f', data[12]+data[13]+data[14]+data[15])\n u = struct.unpack('f', data[16]+data[17]+data[18]+data[19])\n \n self.time = t[0]*25e-9\n \n # prepare the string output\n aux_str = \" t = \"+str(self.time)+\"\\t\"\n aux_str += \" r = \"+str(r[0])+\"\\t\"\n aux_str += \" u = \"+str(u[0])+\"\\t\"\n aux_str += \" x1 = \"+str(x1[0])+\"\\t\"\n aux_str += \" x0 = \"+str(x0[0])+\"\\n\"\n # print string output\n self.textBrowser.insertPlainText(aux_str)\n \n # append data to the arrays\n self.graf_t.append(self.time)\n self.graf_r.append(r[0])\n self.graf_x0.append(x0[0])\n self.graf_x1.append(x1[0])\n self.graf_u.append(u[0])\n \n # remove one value if the arrays have maximum length\n if self.graf_t.buffer_info()[1] >= NUM_SAMPLES:\n self.graf_t.pop(0)\n self.graf_r.pop(0)\n self.graf_x0.pop(0)\n self.graf_x1.pop(0)\n self.graf_u.pop(0)\n \n # reload number of samples lavel\n self.label_samples_value.setText(str(self.graf_t.buffer_info()[1]))\n # reload number of waiting chars in serial rx buffer\n self.label_rx_buff_value.setText(str(self.ser.inWaiting()))\n\n # reload mutex area\n self.updated_data = 1\n \n # prove if there are available id's\n if (self.actionPC_Monitor.isChecked() and data[20] == chr(2)):\n # if it is true, looks how much id's\n i = struct.unpack('B', data[21])\n\n if i[0] < STACK_SIZE:\n for z in range(i[0]):\n new_device = struct.unpack('B', data[z+22])\n new_string = str(new_device[0])\n \n llista = self.listWidget_link.findItems(new_string, QtCore.Qt.MatchExactly)\n if len(llista) == 0:\n self.listWidget_link.addItem(new_string)","def read_raw(self):\n beats = self.microblaze.read_mailbox(0x4)\n interval_ms = self.microblaze.read_mailbox(0x8 + (beats % 4)*4)\n return beats, interval_ms","def read_all_registers(self):\n return self.REGISTERS","def read(self):\r\n\t\tself.mmio.write(iop_const.MAILBOX_OFFSET +\r\n\t\t\t\t\t\tiop_const.MAILBOX_PY2IOP_CMD_OFFSET, 0x3) \r\n\t\twhile (self.mmio.read(iop_const.MAILBOX_OFFSET +\r\n\t\t\t\t\t\t\t\tiop_const.MAILBOX_PY2IOP_CMD_OFFSET) == 0x3):\r\n\t\t\tpass\r\n\t\tmx = self._reg2int(self.mmio.read(iop_const.MAILBOX_OFFSET))\r\n\t\tmy = self._reg2int(self.mmio.read(iop_const.MAILBOX_OFFSET+4))\r\n\t\tmz = self._reg2int(self.mmio.read(iop_const.MAILBOX_OFFSET+8))\r\n\t\treturn [float(\"{0:.2f}\".format(mx*0.004)),\r\n\t\t\t\tfloat(\"{0:.2f}\".format(my*0.004)),\r\n\t\t\t\tfloat(\"{0:.2f}\".format(mz*0.004))]","def recv_data(self):\n data = \"\"\n size = 0\n\n try:\n size = self.sockObj.recv(4) #Get metadata\n except:\n raise Exception(\"Error while receiving data. Probably broken pipe\")\n\n if len(size) == 0:\n raise Exception(\"No data recivied. Probably broken pipe\")\n\n size = struct.unpack('>I',size)[0]\n\n data = self.sockObj.recv(size)\n\n if len(data) != size:\n raise Exception(\"Partiala data recivied\")\n\n return self.decode(data)","def get_data(self):\n return {\"bcode\": self.barcode, \"prodid\": self.product_id}","def _receive(self, what, address='localhost:502', **kwargs):\n colon_index = address.find(':')\n IP = '-i {} '.format(address[:colon_index])\n PORT = '-p {} '.format(address[colon_index+1:])\n # NOTE: following data is validated by client script\n MODE = '-m {} '.format('r')\n TYPE = '-t {} '.format(what[0])\n OFFSET = '-o {} '.format(what[1]) # NOTE: 0-based\n\n # NOTE: kwargs\n if 'count' in kwargs:\n count = kwargs['count']\n COUNT = '--count {} '.format(kwargs['count'])\n else:\n count = 1\n COUNT = '--count {} '.format(1)\n\n cmd = shlex.split(\n self._client_cmd +\n IP +\n PORT +\n MODE +\n TYPE +\n OFFSET +\n COUNT\n )\n # print 'DEBUG modbus_receive cmd shlex list: ', cmd\n\n try:\n client = subprocess.Popen(cmd, shell=False,\n stdout=subprocess.PIPE)\n\n # client.communicate is blocking\n raw_out = client.communicate()\n # print 'DEBUG modbus _receive raw_out: ', raw_out\n\n # value is stored as first tuple element\n # between a pair of square brackets\n raw_string = raw_out[0].strip()\n\n # NOTE: registers store int\n if what[0] == 'HR' or what[0] == 'IR':\n\n # NOTE: single read returns an int\n if count == 1:\n out = int(raw_string[1:-1])\n\n # NOTE: multiple reads returns a list of ints\n else:\n out = []\n hrs = raw_string[1:-1].split(',')\n for hr in hrs:\n out.append(int(hr))\n if len(out) != count:\n raise ValueError('Wrong number of values in the response.')\n\n # NOTE: coils and discrete inputs store 8 bools\n elif what[0] == 'CO' or what[0] == 'DI':\n # print 'DEBUG modbus _receive bools: ', bools\n\n # NOTE: pymodbus always returns at least a list of 8 bools\n bools = raw_string[1:-1].split(',')\n\n # NOTE: single read returns a bool\n if count == 1:\n if bools[0] == 'False':\n out = False\n elif bools[0] == 'True':\n out = True\n else:\n raise TypeError('CO or DI values must be bool.')\n\n # NOTE: multiple reads returns a list of bools\n else:\n out = []\n i = 0\n for b in bools:\n if i >= count:\n break\n elif b.strip() == 'False':\n out.append(False)\n elif b.strip() == 'True':\n out.append(True)\n else:\n raise TypeError('CO or DI values must be bool.')\n i += 1\n\n return out\n\n except Exception as error:\n print('ERROR modbus _receive: ', error)","def fetch_data(self):","def data(self):\n return self._data"],"string":"[\n \"def get_bus_details():\\n\\n\\tbus_detail = db.session.query(Bus.bus_name == (Bus.bus_name)).one()\\n\\n \\n\\treturn bus_detail\",\n \"def get_bus_list():\\n\\n\\tbuses = db.session.query(Bus.bus_name).all()\\n\\n \\n\\treturn buses\",\n \"def _read_data(self):\",\n \"def readOneData(self):\\n\\t\\tpass\",\n \"def get_all(self):\\n try:\\n return self.current_data\\n except:\\n print('No data received from sensor')\",\n \"def read(self):\",\n \"def request_busG():\\n busG = {}\\n for x in G.nodes.items():\\n if x[1].get('highway') == 'bus_stop':\\n xy = []\\n xy.append(x[1].get('osmid'))\\n xy.append(x[1].get('x'))\\n xy.append(x[1].get('y'))\\n busG[x[1].get('osmid')] = xy\\n\\n return busG\",\n \"def bus_dict(self):\\n return self.__bus_dict\",\n \"def read_serial_data(self):\\n qdata = list(get_all_from_queue(self.data_q))\\n if len(qdata) > 0:\\n data = self.data+''.join(qdata)\\n while data.find(\\\"Id: \\\")!=-1:\\n msgStart = data.find(\\\"Id: \\\")\\n msgEnd = data.find(\\\"\\\\n\\\",msgStart)\\n if msgEnd == -1:\\n break\\n\\n packet = data[msgStart:msgEnd-1]\\n # print \\\"msg: [%s]\\\" % packet\\n msgId = int(packet[4:8],16)\\n # print \\\"msgId: %d [%x]\\\" % (msgId, msgId)\\n msgData = map(lambda x: int(x,16) ,packet[16:].split(\\\" \\\"))\\n # print \\\"data: \\\", msgData\\n self.update_data(msgId, msgData)\\n\\n data = data[msgEnd:]\\n self.data = data\",\n \"def get_data(self):\\n return read_sensor(bus=self.bus,\\n address=self.address)\",\n \"def get_data(self):\",\n \"def read(self):\\n temp = self.bus.read_i2c_block_data(self.address, 0)\\n print('temp', temp)\\n return_buffer = []\\n for i in temp:\\n return_buffer += str(chr(int(i)))\\n\\n return return_buffer\",\n \"def registers(self):\\n data = int(0)\\n # length = data.from_bytes(self.length, 'big')\\n length = len(self.contents)\\n print(\\\"recv data length is {}\\\".format(length))\\n format = '!%dH'% (length/2)\\n # print(len(self.contents))\\n registers_data = struct.unpack(format, self.contents)\\n\\n return list(registers_data)\",\n \"def data(self):\",\n \"def get_bus_location():\\n\\n transit_data = cache.get(\\\"transit_data\\\")\\n if transit_data:\\n return transit_data\\n \\n routes = get_routes()\\n\\n live_data_url = \\\"http://gtfs.edmonton.ca/TMGTFSRealTimeWebService/Vehicle/VehiclePositions.pb\\\"\\n feed = gtfs_realtime_pb2.FeedMessage()\\n live_data_response = requests.get(live_data_url)\\n feed.ParseFromString(live_data_response.content)\\n\\n transit_data = {} # contains the informtion for all the busses\\n for entity in feed.entity:\\n if entity.HasField(\\\"vehicle\\\"):\\n trip_number = entity.vehicle.trip.trip_id\\n # sometimes the live bus trip ids don't show up in the routes database\\n if trip_number not in routes:\\n continue\\n\\n bus_number, bus_title = routes[trip_number]\\n vehicle = entity.vehicle.vehicle.id\\n \\n # the higher one seems to be correct - sometimes the vehicle id is too short\\n if entity.vehicle.vehicle.label:\\n vehicle = max(int(entity.vehicle.vehicle.id),\\n int(entity.vehicle.vehicle.label))\\n latitude = entity.vehicle.position.latitude\\n longitude = entity.vehicle.position.longitude\\n bearing = entity.vehicle.position.bearing\\n\\n vehicle_data = {\\\"bus_number\\\": bus_number,\\n \\\"bus_title\\\": bus_title,\\n \\\"latitude\\\": latitude,\\n \\\"longitude\\\": longitude,\\n \\\"bearing\\\": bearing,\\n \\\"trip_id\\\": trip_number}\\n\\n transit_data[vehicle] = vehicle_data\\n \\n cache.set(\\\"transit_data\\\", transit_data, timeout=15)\\n return(transit_data)\",\n \"def get_data(self):\\n self._send_command(self._adapter.get_data())\",\n \"def get_bus(self):\\n return self._bus\",\n \"def _get_data(self):\\n c = Connector(self.host, self.username, self.password)\\n return c.getLanDevices()\",\n \"def collect_data():\\n\\n \\\"Aqui va el codigo de alberto para recoger los datos que puede venir en forma de diccionario\\\"\\n #TODO: Función para recoger los datos de los bms y meterlos en diccionarios (Alberto jr.)\\n\\n bms1 = dict()\\n bms2 = dict()\\n bms3 = dict()\\n general = dict()\\n\\n\\n # Ejemplos de datos para meter en los diccionarios\\n\\n temperature = 35.5\\n voltage1 = 15.2\\n voltage2 = 14.8\\n date = time.strftime(\\\"%Y-%m-%d\\\") # Current date\\n t = time.strftime(\\\"%H:%M:%S\\\") # Current time\\n\\n return bms1, bms2, bms3, general\",\n \"def _wbt_read_data(self):\\n\\t\\treaData = True\\n\\t\\twbtIncomingData = False\\n\\t\\twbtData = \\\"\\\"\\n\\t\\twhile reaData:\\n\\t\\t\\twbtIncomingMsg = self._webots.stdout.readline().rstrip(\\\"\\\\n\\\").split()\\n\\t\\t\\tif \\\"COMM_OUT\\\" in wbtIncomingMsg: wbtIncomingData = True\\n\\t\\t\\telif \\\"END\\\" in wbtIncomingMsg: reaData = False\\n\\t\\t\\telif wbtIncomingData: wbtData += \\\" \\\".join(wbtIncomingMsg[1:])+\\\"\\\\n\\\"\\n\\t\\t\\tprint \\\"\\\\t\\\\t\\\\t\\\\tWebots: :\\\"+\\\" \\\".join(wbtIncomingMsg[1:])\\n\\t\\treturn wbtData\",\n \"def get_data(self):\\n self.dev.write(1, 'A0')\\n digit1, digit2 = self.dev.read(0x81, 64)[:2]\\n # Save the data as voltage between 0.0 and 5.0\\n self.data0.append((digit1 + 256*digit2)*5.0/1024)\",\n \"def query(self):\\n self.bus.write('@\\\\x51\\\\r\\\\n')\\n response = self.bus.read(23)\\n return response\",\n \"def testAllRead(self):\\n import time,copy\\n time.sleep(2)\\n client = ModbusTCP(self.config['vdevs']['slave']['icsifaces'][0],\\n self.config['vdevs']['slave']['points']) \\n\\n pts = copy.deepcopy(self.config['vdevs']['slave']['points'])\\n ptnames = [ pt['name'] for pt in pts ]\\n reply = client.readPoints(ptnames)\\n #print \\\"Reply: \\\", reply\\n for pt in ptnames:\\n value = filter(lambda x: x['name']==pt, pts)[0]['value']\\n #assert value == reply[ptnames.index(pt)]\\n received = reply[ptnames.index(pt)]\\n if not value == received: \\n print pt, ' was %s but should be %s'%(str(received),str(value))\",\n \"def s_read(self, timeout = 1):\\n if self.s.is_open:\\n data = [] \\n b = bytearray()\\n try:\\n self.s.timeout = 3\\n data = self.s.read(1)\\n \\n if not len(data):\\n return b\\n\\n self.s.timeout = .04\\n data += self.s.read(500)\\n except Exception as e:\\n print(\\\"Could not read from port\\\" + str(e))\\n\\n start = data.find(b'\\\\x7e')\\n end = data.find(b'\\\\x7f')\\n\\n txt_start = b''\\n txt_end = b''\\n if start < 0:\\n txt_start = data\\n elif end < 0:\\n txt_start = data\\n else:\\n txt_start = data[0:start]\\n txt_end = data[end+1:]\\n\\n txt = txt_start + txt_end\\n if len(txt):\\n if self.log_ascii:\\n self.logfile.write(txt)\\n\\n # End logging \\n if Connection.START_UP_STRING in data:\\n raise Reset_Exception('ChipSHOUTER unit has reset - wait 5 seconds then reinitialize.') \\n\\n if start < 0 or end < 0 or end < start:\\n b = bytearray()\\n return b\\n if self.log_input:\\n self.logfile.write('\\\\nIN :' + str(len(data)) + '[' + hexlify(data) + ']' + '\\\\n')\\n b.extend(data[start:end])\\n return b\\n else:\\n raise IOError('Comport is not open, use ctl_connect()')\",\n \"def get_data(self):\\n self._zmq_request.send(b'next')\\n return msgpack.loads(self._zmq_request.recv())\",\n \"def get_cmdb_data(device_type):\\n pass\",\n \"def read_drt(self):\\n data = Array('B')\\n data = self.read(0, 0, 8)\\n num_of_devices = drt_controller.get_number_of_devices(data)\\n len_to_read = num_of_devices * 8\\n\\n data = self.read(0, 0, len_to_read + 8)\\n self.drt_manager.set_drt(data)\",\n \"def recive_data(self, socket_cliente):\\n # Protocolo de informacion\\n data = bytearray()\\n bytes_largo = socket_cliente.recv(4)\\n largo_bytes = int.from_bytes(bytes_largo, byteorder=\\\"big\\\")\\n numero_chunks = (largo_bytes // 60) + 1\\n for i in range(numero_chunks):\\n numero_bloque = socket_cliente.recv(4)\\n data_bloque = socket_cliente.recv(60)\\n if i == (numero_chunks - 1):\\n data_bloque = data_bloque[0: (largo_bytes % 60)]\\n data.extend(data_bloque)\\n\\n if data == \\\"\\\":\\n pass\\n else:\\n return data\",\n \"def get_readings(self):\\n buf = self._read(0x020001)\\n data = decode(buf[1:])\\n return data\",\n \"def get_data():\\n pass\",\n \"def get_nmea_data(port):\\n \\n# q = 1 # quality factor\\n \\n # Wait for RMC message :\\n rmc = port.readline().decode(\\\"utf-8\\\")\\n while not 'RMC' in rmc:\\n if rmc: \\n print(\\\"Wait for RMC : \\\", rmc)\\n rmc = port.readline().decode(\\\"utf-8\\\")\\n\\n \\n # Read GGA+GST+ZDA messages :\\n gga = port.readline().decode(\\\"utf-8\\\")\\n gst = port.readline().decode(\\\"utf-8\\\")\\n zda = port.readline().decode(\\\"utf-8\\\")\\n \\n t = np.float(gga[7:16])\\n \\n # Print messages :\\n print(\\\"Trames :\\\")\\n print(\\\" RMC: \\\",rmc)\\n print(\\\" GGA: \\\",gga)\\n print(\\\" GST: \\\",gst)\\n print(\\\" ZDA: \\\",zda)\\n \\n # Quality check :\\n if not 'GGA' in gga or not 'GST' in gst or not 'ZDA' in zda:\\n print(\\\"Issue with GGA/GST/ZDA frame decoding !\\\\nMessage:\\\\nGGA:{0}\\\\nGST:{1}\\\\nZDA:{2}\\\".format(gga, gst, zda))\\n rmc, gga, gst, zda, t = get_nmea_data(port)\\n \\n return rmc, gga, gst, zda, t\",\n \"def get_data(self):\\r\\n pass\",\n \"def readData(self):\\n if (self.model == 'GDS'):\\n self.write(':ACQ'+str(ch)+':MEM?\\\\n')\\n elif (self.model == 'TDS'):\\n self.write('CURVe?\\\\n')\\n\\n # Check for the initial '#'; if not present, raise error.\\n if (self.read(1) != '#'):\\n raise Exception, \\\"Expected header not present\\\"\\n\\n # Read the data length indicator\\n dataSize = int(self.read(int(self.read(1))))\\n\\n # extra steps for GDS\\n if (self.model == 'GDS'):\\n # subtract the 8 bytes we will read.\\n dataSize -= 8\\n # Read the sampling period\\n hstep = struct.unpack('>f', self.read(4))[0]\\n # also, fix hoff so it corresponds with that for TDS\\n # FIXME: check with the scope at some point.\\n hoff = hoff - float(dataSize/4) * hstep\\n # Read 4 bytes to advance to the actual data: first byte\\n # contains the channel and the three are not used,\\n # according to the GDS800 manual.\\n self.read(4)\\n \\n # Read data; TDS expects a 1-byte data, GDS expects 2-byte one.\\n if (self.model == 'TDS'):\\n data = list(struct.unpack('>'+str(dataSize)+'b',\\n self.read(dataSize)))\\n # TDS has a trailing '\\\\n' that should be drained.\\n self.read(1)\\n elif (self.model == 'GDS'):\\n data = list(struct.unpack('>'+str(dataSize/2)+'h',\\n self.read(dataSize)))\\n\\n return data\",\n \"def bus_func(self, bus):\\n return 0\",\n \"def _do_get_values(self, args):\\r\\n bus_type = args[1]\\r\\n slave_id = int(args[2])\\r\\n name = args[3]\\r\\n address = int(args[4])\\r\\n length = int(args[5])\\r\\n if bus_type == 'rtu':\\r\\n slave = self.server._servers[0].get_slave(slave_id)\\r\\n elif bus_type == 'tcp':\\r\\n slave = self.server._servers[1].get_slave(slave_id)\\r\\n values = slave.get_values(name, address, length)\\r\\n return self._tuple_to_str(values)\",\n \"def get_data(self):\\n data = {\\n \\\"ts\\\": self.drone.pos[0][0],\\n \\\"drone\\\": self.drone,\\n \\\"subject\\\": self.subject,\\n \\\"peds\\\": self.peds, # can be None\\n \\\"objs\\\": self.objs # can be None\\n }\\n self.empty_bag()\\n return data\",\n \"def read():\\n # TODO\",\n \"def testAllRead(self):\\n import time,copy\\n time.sleep(2)\\n to_config = self.config['vdevs']['slave']['icsifaces'][0]\\n from_config = self.config['vdevs']['master']['clientifaces'][0]\\n points = self.config['vdevs']['slave']['points']\\n client = ModbusRTU(to_config, points, from_config)\\n\\n\\n pts = copy.deepcopy(self.config['vdevs']['slave']['points'])\\n for i in xrange(50):\\n ptnames = [ pt['name'] for pt in pts ]\\n reply = client.readPoints(ptnames)\\n #print \\\"Reply: \\\", reply\\n for pt in ptnames:\\n value = filter(lambda x: x['name']==pt, pts)[0]['value']\\n #assert value == reply[ptnames.index(pt)]\\n received = reply[ptnames.index(pt)]\\n if not value == received: \\n print pt, ' was %s but should be %s'%(str(received),str(value))\",\n \"def next_bus(stop_point):\\n stop = str(stop_point)\\n r = requests.get('https://api-radon.tfl.gov.uk/StopPoint/' + stop_point + '/Arrivals')\\n print(r)\\n json_result = r.json()\\n all_stops = json_result\\n my_buses = []\\n for i in all_stops:\\n i = '{}, {}-min'.format(str(i['destinationName']),str(round(i['timeToStation']/60)))\\n my_buses.append(i)\\n return my_buses\",\n \"def servo_read_all(self):\\n msg = b'\\\\x25\\\\x00'\\n parameter_len = 16\\n ans = self.__bt.read(msg, parameter_len)\\n if ans is not None:\\n return [x for x in ans]\\n return None\",\n \"def getData(self):\\n self.ser.write(b'g')\\n readString = self.ser.readline()\\n print(readString)\\n readString = readString.decode(\\\"utf-8\\\")\\n splittedString = readString.split('\\\\t')\\n for i, num in enumerate(splittedString):\\n try:\\n splittedString[i] = int(float(num))\\n except ValueError:\\n pass\\n self.accString.set('Accleration\\\\nX: %.5f\\\\nY: %.5f\\\\nZ: %.5f' %\\n (splittedString[0], splittedString[1],\\n splittedString[2]))\\n self.logFile.write(readString)\\n self.comJob = root.after(10, self.getData)\",\n \"def get_station_boroughs(self):\\\\\",\n \"def read(self):\\n \\n #self.lego_bus.write_byte(self.address, 0xF5)\\n #time.sleep(0.2)\\n block=0\\n rawhumidity=0\\n counter=0\\n toRead=0\\n while counter < 10 and toRead != 3:\\n self.lego_bus.write_byte(self.address, 0xFE)\\n self.lego_bus.write_byte(self.address, 0xF5)\\n sleep(1)\\n \\n try:\\n block = self.lego_bus.read_i2c_block_data(self.address, 0, 3)\\n print (block)\\n rawhumidity = (( block[0] << 8) | block[1])\\n print (rawhumidity)\\n except:\\n print(\\\"Error inesperado:\\\", sys.exc_info()[0])\\n counter +=1\\n \\n\\n rh=999 # if invalid checksum return error value\\n if (self.check_crc(rawhumidity, block[2]) == 0): #Verify the checksum \\n #rawhumidity &= 0xFFFC\\n print (rawhumidity)\\n tempRH = rawhumidity / 65536.0\\n rh = -6.0 + (125.0 * tempRH)\\n return rh\",\n \"def get_data(self):\\n pass\",\n \"def get_data(self):\\n pass\",\n \"def read_buffer(serial):\\r\\n resp = serial.read_all()\\r\\n return resp.decode()\",\n \"def getAll(self):\\n return self.dataBuffer\",\n \"def getData(self,cmd):\\n self.ser.write(cmd.encode()+END.encode())\\n out = self.ser.readline()\\n\\n if(out == \\\"\\\"):\\n raise IOError(\\\"communication failed\\\")\\n return out\",\n \"def recibir(self):\\r\\n lenbuf = self.__recvall(4)\\r\\n longitud, = struct.unpack('!I', lenbuf)\\r\\n return self.__recvall(longitud)\",\n \"def sample(self):\\n print(\\\"sampling bluetooth arduino\\\")\\n self.sock.send(b'B')\\n data = b''\\n '''while True:\\n data += self.sock.recv(1024)\\n if data.endswith(b'\\\\n'):\\n break\\n '''\\n #self.sock.settimeout(2)\\n try:\\n while True:\\n d = self.sock.recv(255)\\n data += d\\n if d.find(b'\\\\n') != -1:\\n break\\n except Exception as err:\\n print(err)\\n pass\\n print(data)\\n data = json.loads(data.decode())\\n if not any(x == 0 for x in data.values()):\\n for label in self.data_labels:\\n self.data[label].append(data[label])\\n #self.data[\\\"time\\\"].append(time.time() - self.start)\\n print(data)\\n #print(self.data)\\n #return self.data\",\n \"def read_holding_registers(self, unit, address, length):\\r\\n # generate jbus request \\r\\n request = Request(function_code=3, unit=unit, address=address, length=length)\\r\\n \\r\\n _logger.debug(\\\"Request is {}\\\".format(request.bytes))\\r\\n\\r\\n # generate jbus response\\r\\n response = self.transition.execute(request)\\r\\n return response\",\n \"def get_all_data(self):\\n\\t\\treply = self._send_command_to_entity_server(us.SERVER_COMMAND_REQUEST_ALL_DATA)\\n\\t\\t#print(reply)\\n\\t\\treturn reply\",\n \"def read(self):\\n try:\\n cmd = 'SAMP:COUN 1' \\n self.handle.write(cmd) #one sample per trigger\\n self.handle.write('TRIG:SOUR BUS') #triggered by command\\n self.handle.write('TRIG:COUN 1') #one trigger to return to wait for trg\\n self.handle.write('INIT:IMM') #DVM to \\\"wait for trigger\\\" \\n self.handle.write('*TRG')\\n startTime = time.time()\\n while True: #wait until measuring flag goes to 0\\n try:\\n measured = self.handle.ask(\\\"DATA:POIN?\\\")\\n measured = measured.strip() #remove CR \\n measured = int(measured) #convert to number\\n if measured == 1: #final number of samples achieved\\n break;\\n except Exception:\\n print('Dvm34411:read() polling failed !')\\n raise\\n \\n if time.time() - startTime > self.timeout:\\n print('Dvm34411:read() timeout !')\\n return False\\n \\n time.sleep(1) \\n reading = self.handle.ask('R? 1;') #definite-Length block format\\n except Exception:\\n print('Dvm34411.read() failed !')\\n raise\\n if reading[0] != '#':\\n print('Dvm34411.read() DLB format error - # expected !')\\n return False\\n digits = int(reading[1])\\n reading = reading[2 + digits:]\\n rdg = float(reading)\\n return rdg\",\n \"def _read(self, register):\\n\\n addr, num_bytes = register\\n data = response = error = None\\n if num_bytes == 1:\\n data, response, error = self.packet_handler.read1ByteTxRx(\\n self.port_handler, self._id, addr\\n )\\n elif num_bytes == 2:\\n data, response, error = self.packet_handler.read2ByteTxRx(\\n self.port_handler, self._id, addr\\n )\\n else:\\n data, response, error = self.packet_handler.read4ByteTxRx(\\n self.port_handler, self._id, addr\\n )\\n\\n # Check response\\n self._error_handler(response, error)\\n\\n return data\",\n \"def _usb_get_report(self):\\n arraydata=self.usbdev.ctrl_transfer(bmRequestType=0xa1, bRequest=0x01, wValue=0x03b0, wIndex=0, data_or_wLength=9)\\n data=arraydata.tolist()\\n assert (data[0:4]==[0xb0,0x00,0x00,0x01]) or \\\\\\n (data[0:4]==[0xb0,0xaa,0x00,0x01]) or \\\\\\n (data[0:4]==[0xb0,0xaa,0x00,0x00]), \\\\\\n 'unexpected device status info start: %s'%(data[0:4])\\n assert data[8]==1,'unexpected last byte value: %s'%data[8]\\n position=data[4:6]\\n v_pos=data[6]\\n self.vertical_position=v2k(v_pos,V_POS)\\n self.intensity=data[7]\\n self.position=v2k(position,POSITION)\\n return(data)\",\n \"def get_data():\\n return\",\n \"def parse(self):\\n i = 1\\n times = []\\n while 1:\\n byte = yield\\n if byte== 0xaa:\\n byte = yield # This byte should be \\\"\\\\aa\\\" too\\n if byte== 0xaa:\\n # packet synced by 0xaa 0xaa\\n packet_length = yield\\n packet_code = yield\\n if packet_code == 0xd4:\\n # standing by\\n self.state = \\\"standby\\\"\\n elif packet_code == 0xd0:\\n self.state = \\\"connected\\\"\\n elif packet_code == 0xd2:\\n data_len = yield\\n headset_id = yield\\n headset_id += yield\\n self.dongle_state = \\\"disconnected\\\"\\n else:\\n self.sending_data = True\\n left = packet_length - 2\\n while left>0:\\n if packet_code ==0x80: # raw value\\n row_length = yield\\n a = yield\\n b = yield\\n value = struct.unpack(\\\"<h\\\",chr(b)+chr(a))[0]\\n self.dispatch_data(\\\"raw\\\", value)\\n left -= 2\\n elif packet_code == 0x02: # Poor signal\\n a = yield\\n\\n left -= 1\\n elif packet_code == 0x04: # Attention (eSense)\\n a = yield\\n if a>0:\\n v = struct.unpack(\\\"b\\\",chr(a))[0]\\n if 0 < v <= 100:\\n self.dispatch_data(\\\"attention\\\", v)\\n left-=1\\n elif packet_code == 0x05: # Meditation (eSense)\\n a = yield\\n if a>0:\\n v = struct.unpack(\\\"b\\\",chr(a))[0]\\n if 0 < v <= 100:\\n self.dispatch_data(\\\"meditation\\\", v)\\n left-=1\\n elif packet_code == 0x16: # Blink Strength\\n self.current_blink_strength = yield\\n \\n left-=1\\n elif packet_code == 0x83:\\n vlength = yield\\n self.current_vector = []\\n for row in range(8):\\n a = yield\\n b = yield\\n c = yield\\n value = a*255*255+b*255+c\\n left -= vlength\\n self.dispatch_data(\\\"bands\\\", self.current_vector)\\n packet_code = yield\\n else:\\n pass # sync failed\\n else:\\n pass # sync failed\",\n \"def __get_data(self):\\n ips = self.server.JUGADORES.keys()\\n convida = list(ips)\\n retorno = \\\"\\\"\\n for ip in ips:\\n nick = self.server.JUGADORES[ip]['nick']\\n tanque = self.server.JUGADORES[ip]['path']\\n energia = self.server.JUGADORES[ip]['energia']\\n vidas = self.server.JUGADORES[ip]['vidas']\\n puntos = self.server.JUGADORES[ip]['puntos']\\n posicion = self.server.JUGADORES[ip]['pos']\\n bala = self.server.JUGADORES[ip]['bala']\\n\\n datos = \\\"%s,%s,%s,%s,%s,%s,%s,%s\\\" % (ip, nick, tanque,\\n posicion, vidas, energia, puntos, bala)\\n\\n explosion = self.server.JUGADORES[ip]['explosiones'].get(\\n self.client_address[0], False)\\n if explosion:\\n datos = \\\"%s,%s\\\" % (datos, explosion)\\n del(self.server.JUGADORES[ip][\\n 'explosiones'][self.client_address[0]])\\n\\n retorno = \\\"%s%s||\\\" % (retorno, datos)\\n if vidas == 0:\\n convida.remove(ip)\\n\\n if len(ips) > 1 and len(convida) == 1:\\n return \\\"END\\\"\\n else:\\n return retorno.strip()\",\n \"def read_data(self):\\n raise NotImplementedError\",\n \"def read(self, reg):\\n return self.bus.read_byte_data(self.address, reg)\",\n \"def get_data(self):\\n if self.ser.in_waiting:\\n data_string = self.ser.readline().decode().strip()\\n if not data_string: return self.data\\n self.data = [\\n float(element) for element in data_string.split()\\n ]\\n self.ser.reset_input_buffer()\\n return self.data\",\n \"def getData(self):\\n return struct.unpack(\\\"!Q\\\",self.data)[0]\",\n \"def getData(self):\\n return struct.unpack(\\\"!Q\\\",self.data)[0]\",\n \"def getAllData(self):\\r\\n return self.data\",\n \"def getData(self):\\n data = self.rx.getNData()\\n\\n return (data)\",\n \"def read_from_serial(self):\\n output = b''\\n time.sleep(self._sleep_time)\\n while self._ser.inWaiting() > 0:\\n output = output + self._ser.read(1)\\n #A default ten powercycle delay means that some measurements may still be processing\\n #by the time the read function is called. This slows down the read but ensures that\\n #it will finish (per my testing). There is probably a better way to do this. TODO\\n time.sleep(0.06)\\n return output.decode('utf-8').strip()\",\n \"def achieve_data(self, selection='all'):\\r\\n Infra_Omi, Infra_L, Infra_R = None, None,None\\r\\n bump, L_cnt, R_cnt, DLightBump, AnalogBump = None,None,None,None,None\\r\\n if selection == 'b':\\r\\n # read bumper data only\\r\\n Infra_Omi,Infra_L, Infra_R, bump,DLightBump, L, FL, CL, CR, FR, R = self.Roomba.ReadQueryStream(17,52,53, 7,45, 46, 47,48, 49, 50, 51)\\r\\n AnalogBump = (L, FL, CL, CR, FR, R)\\r\\n elif selection == 'e':\\r\\n # read encoder data only\\r\\n L_cnt, R_cnt= self.Roomba.ReadQueryStream( 43, 44)\\r\\n else:\\r\\n # read all data\\r\\n Infra_Omi, Infra_L, Infra_R,bump, L_cnt,R_cnt, DLightBump, L,FL, CL,CR,FR,R =self.Roomba.ReadQueryStream(17,52,53,7, 43, 44, 45, 46,47,48,49,50,51 )\\r\\n AnalogBump = (L,FL, CL,CR,FR,R)\\r\\n\\r\\n return L_cnt,R_cnt, bump, DLightBump,AnalogBump,Infra_Omi, Infra_L, Infra_R\",\n \"def receive_data(self, conn):\\n data = conn.recv(2048)\\n message = data.decode('utf-8')\\n currDev = ''\\n if message != self.last_message and message != '':\\n if len(message) >= 24:\\n for letter in message:\\n currDev += letter\\n if len(currDev) == 12:\\n self.list_of_devices += [currDev]\\n currDev = ''\\n else:\\n self.list_of_devices = [message]\\n\\n print(self.list_of_devices)\",\n \"def read_data(self):\\n temperature_data = RS485.read_temperature(self.data_path)\\n humidity_data = RS485.read_humidity(self.data_path)\\n moisture_data = RH_010_GN.read_moisture(self.data_path)\\n o2_data = LB_856.read_o2(self.data_path)\\n co2_data = LB_856.read_co2(self.data_path)\\n\\n self.data = [temperature_data, humidity_data, moisture_data, o2_data, co2_data]\",\n \"def data(self):\\n pass\",\n \"def data(self):\\n pass\",\n \"def GetData(self):\\r\\n \\r\\n return self._data\",\n \"def get_data(self):\\n try:\\n data_string = self.ser.readline().decode()\\n except UnicodeDecodeError as e:\\n return self.get_data()\\n \\n if not data_string: # check for empty string\\n return self.get_data()\\n \\n if data_string[0] == '|' and data_string[-1] == '\\\\n' and\\\\\\n self.reset_confirmed:\\n # if the data_string is valid, process it\\n try:\\n data_string = data_string.strip() \\n data = data_string.split(',')\\n assert len(data) == 7, \\\"Bad data Length\\\" \\n data = [float(val) for val in data[1:]]\\n data[0] /= 1000\\n if self.ser.in_waiting: self.ser.reset_input_buffer()\\n return data\\n except (AssertionError, ValueError) as e:\\n print(\\\"Error:\\\", type(e), e)\\n if self.ser.in_waiting: self.ser.reset_input_buffer()\\n return self.get_data()\\n\\n\\n elif data_string[0] == '+' and data_string[-1] == '\\\\n' and\\\\\\n self.reset_confirmed:\\n # if the data_string is a valid time stamp, process it\\n # self.system_timestamp = \\\"\\\\nSystem start time is: \\\"\\\\\\n # \\\"%s\\\" % strftime(\\\"%Y/%m/%d %H:%M:%S\\\", localtime())\\n self.arduino_timestamp = data_string.strip()\\n print(self.arduino_timestamp)\\n return self.get_data()\\n \\n elif data_string[0] == '/' and data_string[-1] == '\\\\n':\\n # if string begins with / then it is a debug message and should\\n # just be returned\\n if \\\"setup finished\\\" in data_string.lower(): \\n self.reset_confirmed = True\\n print(data_string.strip())\\n return self.get_data()\\n else:\\n # if the data_string is invalid try again\\n return self.get_data()\",\n \"def _read_multiple_bytes_as_array(self, reg_addr, lenght):\\n return self.bus.read_i2c_block_data(self.I2C_ADDRESS, reg_addr, lenght)\",\n \"def get(self):\\n try:\\n log.debug(\\\"Device info : \\\")\\n #get the payload to influx DB\\n url = \\\"http://localhost:8086/query\\\"\\n querystring = {\\\"pretty\\\": \\\"true\\\", \\\"db\\\": \\\"IOT\\\",\\n \\\"q\\\":\\\"SELECT DISTINCT(deviceId) FROM(SELECT deviceId,q1 FROM \\\\\\\"ttd_devices\\\\\\\" ) \\\" }\\n response = requests.request(\\\"GET\\\", url, params=querystring)\\n r_d=json.loads(response.text)\\n result_d=[]\\n for rec in r_d['results'][0]['series']:\\n for element in rec['values']:\\n result_d.append(element[1])\\n result={}\\n result['status'] = 1\\n result['message']=result_d\\n return_status = 200\\n except ValueError as e:\\n result = {}\\n log.exception('Value Exception while fetching device list')\\n result['status'] = 0\\n return_status = 400\\n result['message'] = e.args[0]\\n except :\\n result = {}\\n log.exception('Exception while fetching the device data')\\n return_status = 500\\n result['status'] = 0\\n result['message'] = 'Internal Error has occurred while fetching devie data'\\n finally:\\n resp = Response(json.dumps(result), status=return_status, mimetype=\\\"application/json\\\")\\n return resp\",\n \"def read(self):\\n pass\",\n \"def get_data(self):\\n return {\\n \\\"fd\\\": self.get_fd_j(self.id),\\n \\\"fd_part\\\": self.get_fd_part_j(self.id),\\n \\\"config\\\": self.config,\\n # \\\"config\\\": self.get_config_j(self.id),\\n \\\"prp\\\": self.get_prp_j(self.id),\\n \\\"alll\\\": self.my_alll(self.id)\\n }\",\n \"def _get_data(self):\\n devices = []\\n try:\\n if not self.router_client.login():\\n self.hass.states.set(f\\\"{DOMAIN}.statusmsg\\\", self.router_client.statusmsg)\\n _LOGGER.warning(\\\"Login failed: {0}:{1}@{2}\\\".format(self.router_client.username, self.router_client.password,self.router_client.host))\\n self.router_client.logout()\\n return devices\\n\\n devices_json = self.router_client.get_devices_response()\\n finally:\\n self.router_client.logout()\\n\\n self.hass.states.set(f\\\"{DOMAIN}.scanning\\\", devices_json != False)\\n\\n if devices_json != False:\\n for device in devices_json:\\n # _LOGGER.debug(\\\"Device: {0}\\\".format(device))\\n dev = Device(\\n device['HostName'].replace('未知设备', 'Unknown'),\\n device['IPAddress'],\\n device['MACAddress'],\\n device['Active'],\\n ICONS.get(device['IconType'])\\n )\\n # _LOGGER.debug(\\\"Device: {0}\\\".format(dev))\\n devices.append(dev)\\n return devices\\n else:\\n return []\",\n \"def get(self):\\r\\n return self.data_array\",\n \"def get_array(self):\\r\\n samples = getattr(self.instrument, self.devchan+'_samples')()\\r\\n sample_rate = getattr(self.instrument, self.devchan+'_sample_rate')()\\r\\n timeout = getattr(self.instrument, self.devchan+'_timeout')()\\r\\n return self.instrument.read_analog(self.devchan,\\r\\n samples,\\r\\n sample_rate,\\r\\n timeout,\\r\\n self.chan_config,\\r\\n self.minv,\\r\\n self.maxv,\\r\\n self.triggered,\\r\\n False\\r\\n )\",\n \"async def get_api_data(self) -> dict:\\n if not self.bos.is_set():\\n self.lit = False\\n return self.messages\\n try:\\n # get all data and split it up\\n all_data = await self.send_api_cmd(\\\"devs+temps+fans\\\")\\n devs_raw = all_data['devs'][0]\\n temps_raw = all_data['temps'][0]\\n fans_raw = all_data['fans'][0]\\n\\n # parse temperature data\\n temps_data = {}\\n for board in range(len(temps_raw['TEMPS'])):\\n temps_data[f\\\"board_{temps_raw['TEMPS'][board]['ID']}\\\"] = {}\\n temps_data[f\\\"board_{temps_raw['TEMPS'][board]['ID']}\\\"][\\\"Board\\\"] = temps_raw['TEMPS'][board]['Board']\\n temps_data[f\\\"board_{temps_raw['TEMPS'][board]['ID']}\\\"][\\\"Chip\\\"] = temps_raw['TEMPS'][board]['Chip']\\n\\n # parse individual board and chip temperature data\\n for board in temps_data.keys():\\n if \\\"Board\\\" not in temps_data[board].keys():\\n temps_data[board][\\\"Board\\\"] = 0\\n if \\\"Chip\\\" not in temps_data[board].keys():\\n temps_data[board][\\\"Chip\\\"] = 0\\n\\n # parse hashrate data\\n hr_data = {}\\n for board in range(len(devs_raw['DEVS'])):\\n hr_data[f\\\"board_{devs_raw['DEVS'][board]['ID']}\\\"] = {}\\n hr_data[f\\\"board_{devs_raw['DEVS'][board]['ID']}\\\"][\\\"HR\\\"] = round(\\n devs_raw['DEVS'][board]['MHS 5s'] / 1000000,\\n 2)\\n\\n # parse fan data\\n fans_data = {}\\n for fan in range(len(fans_raw['FANS'])):\\n fans_data[f\\\"fan_{fans_raw['FANS'][fan]['ID']}\\\"] = {}\\n fans_data[f\\\"fan_{fans_raw['FANS'][fan]['ID']}\\\"]['RPM'] = fans_raw['FANS'][fan]['RPM']\\n\\n # set the miner data\\n miner_data = {'IP': self.ip, \\\"Light\\\": \\\"show\\\", 'Fans': fans_data, 'HR': hr_data, 'Temps': temps_data}\\n\\n # save stats for later\\n self.stats = miner_data\\n\\n # return stats\\n return miner_data\\n except:\\n # if it fails, return install data\\n # usually fails on getting None from API\\n self.lit = False\\n data = self.messages\\n data['Light'] = \\\"show\\\"\\n return data\",\n \"def get_scan_data(self):\\n return self.scan_data\",\n \"def transmissionData(self, port='Substrate_bottom'):\\n\\n data = self.data['fluxes']\\n # sorted_layers is an OrderedDict, and thus has the popitem method\\n sorted_layers = self.conf.sorted_dict(self.conf['Layers'])\\n # self.log.info('SORTED LAYERS: %s', str(sorted_layers))\\n first_layer = sorted_layers.popitem(last=False)\\n self.log.info('FIRST LAYER: %s', str(first_layer))\\n # An ordered dict is actually just a list of tuples so we can access\\n # the key directly like so\\n first_name = first_layer[0]\\n bfirst_name = first_name.encode('utf-8')\\n self.log.info('FIRST LAYER NAME: %s', str(first_name))\\n bport = port.encode('utf-8')\\n # p_inc = data[first_name][0]\\n # p_ref = np.abs(data[first_name][1])\\n # p_trans = data[last_name][0]\\n p_inc = np.absolute(data[data.layer == bfirst_name][0][1])\\n p_ref = np.absolute(data[data.layer == bfirst_name][0][2])\\n p_trans = np.absolute(data[data.layer == bport][0][1])\\n reflectance = p_ref / p_inc\\n transmission = p_trans / p_inc\\n absorbance = 1 - reflectance - transmission\\n tot = reflectance + transmission + absorbance\\n delta = np.abs(tot - 1)\\n self.log.info('Reflectance %f' % reflectance)\\n self.log.info('Transmission %f' % transmission)\\n self.log.info('Absorbance %f' % absorbance)\\n self.log.info('Total = %f' % tot)\\n assert(reflectance >= 0)\\n assert(transmission >= 0)\\n assert(absorbance >= 0)\\n # assert(delta < .00001)\\n # Try to get a prexisting array if it exists\\n try:\\n # If array has been computed before get it\\n arr = self.data['transmission_data']\\n # If we already have data at this port update that row, otherwise\\n # resize the array to accomodate the new row and insert the data\\n ind = np.where(arr.port == port.encode('utf-8'))[0]\\n if len(ind) > 0:\\n arr[ind[0]] = (port, reflectance, transmission, absorbance)\\n else:\\n arr = np.resize(arr, arr.shape[0]+1)\\n arr[-1] = (port, reflectance, transmission, absorbance)\\n except:\\n # Otherwise we need to make a new one\\n dt = [('port', 'S25'), ('reflection', 'f8'),\\n ('transmission', 'f8'), ('absorption', 'f8')]\\n arr = np.recarray((1,), dtype=dt)\\n arr[-1] = (port, reflectance, transmission, absorbance)\\n self.data['transmission_data'] = arr\\n return reflectance, transmission, absorbance\",\n \"def get_data(self): # TODO: add smooth possibility\\n return self.data\",\n \"def getData(self):\\n return self.data\",\n \"def getData(self):\\n return self.data\",\n \"def read(self):\\n try:\\n datos = self.base.readData()\\n for i in range(len(datos)):\\n self.verDatos.insert('', i+1, text = i+1, values = (datos[i][0], datos[i][1], datos[i][2]))\\n except:\\n showerror(\\\"Error\\\", exc_info()[1])\",\n \"def _get_data_from_send_queue(self):\\n size = self.send_queue.qsize()\\n if size > 1:\\n data = b''.join([self.send_queue.get() for _ in range(size)])\\n else:\\n data = self.send_queue.get()\\n return data\",\n \"def get_data ( self ):\\n return self._data_pntr.ReadAsArray()\",\n \"def get_data ( self ):\\n return self._data_pntr.ReadAsArray()\",\n \"def __init__(self, bus: int, /):\",\n \"def recive_data(self):\\n # read all available data\\n while self.ser.inWaiting() > self.INPUT_DATA_SIZE+1:\\n data = array.array('c')\\n # search the header\\n data.append(self.ser.read(1))\\n while data[0] != chr(1):\\n data[0] = self.ser.read(1)\\n \\n # wait for all available data\\n while self.ser.inWaiting() < (self.INPUT_DATA_SIZE-1):\\n time.sleep(0.03);\\n \\n # recives data\\n data = self.ser.read(self.INPUT_DATA_SIZE-1)\\n \\n # prove if you want graphical data\\n if self.pushButton_monitor.isChecked():\\n # decodes the data\\n t = struct.unpack('I', data[3]+data[2]+data[1]+data[0])\\n r = struct.unpack('f', data[4]+data[5]+data[6]+data[7])\\n x0 = struct.unpack('f', data[8]+data[9]+data[10]+data[11])\\n x1 = struct.unpack('f', data[12]+data[13]+data[14]+data[15])\\n u = struct.unpack('f', data[16]+data[17]+data[18]+data[19])\\n \\n self.time = t[0]*25e-9\\n \\n # prepare the string output\\n aux_str = \\\" t = \\\"+str(self.time)+\\\"\\\\t\\\"\\n aux_str += \\\" r = \\\"+str(r[0])+\\\"\\\\t\\\"\\n aux_str += \\\" u = \\\"+str(u[0])+\\\"\\\\t\\\"\\n aux_str += \\\" x1 = \\\"+str(x1[0])+\\\"\\\\t\\\"\\n aux_str += \\\" x0 = \\\"+str(x0[0])+\\\"\\\\n\\\"\\n # print string output\\n self.textBrowser.insertPlainText(aux_str)\\n \\n # append data to the arrays\\n self.graf_t.append(self.time)\\n self.graf_r.append(r[0])\\n self.graf_x0.append(x0[0])\\n self.graf_x1.append(x1[0])\\n self.graf_u.append(u[0])\\n \\n # remove one value if the arrays have maximum length\\n if self.graf_t.buffer_info()[1] >= NUM_SAMPLES:\\n self.graf_t.pop(0)\\n self.graf_r.pop(0)\\n self.graf_x0.pop(0)\\n self.graf_x1.pop(0)\\n self.graf_u.pop(0)\\n \\n # reload number of samples lavel\\n self.label_samples_value.setText(str(self.graf_t.buffer_info()[1]))\\n # reload number of waiting chars in serial rx buffer\\n self.label_rx_buff_value.setText(str(self.ser.inWaiting()))\\n\\n # reload mutex area\\n self.updated_data = 1\\n \\n # prove if there are available id's\\n if (self.actionPC_Monitor.isChecked() and data[20] == chr(2)):\\n # if it is true, looks how much id's\\n i = struct.unpack('B', data[21])\\n\\n if i[0] < STACK_SIZE:\\n for z in range(i[0]):\\n new_device = struct.unpack('B', data[z+22])\\n new_string = str(new_device[0])\\n \\n llista = self.listWidget_link.findItems(new_string, QtCore.Qt.MatchExactly)\\n if len(llista) == 0:\\n self.listWidget_link.addItem(new_string)\",\n \"def read_raw(self):\\n beats = self.microblaze.read_mailbox(0x4)\\n interval_ms = self.microblaze.read_mailbox(0x8 + (beats % 4)*4)\\n return beats, interval_ms\",\n \"def read_all_registers(self):\\n return self.REGISTERS\",\n \"def read(self):\\r\\n\\t\\tself.mmio.write(iop_const.MAILBOX_OFFSET +\\r\\n\\t\\t\\t\\t\\t\\tiop_const.MAILBOX_PY2IOP_CMD_OFFSET, 0x3) \\r\\n\\t\\twhile (self.mmio.read(iop_const.MAILBOX_OFFSET +\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tiop_const.MAILBOX_PY2IOP_CMD_OFFSET) == 0x3):\\r\\n\\t\\t\\tpass\\r\\n\\t\\tmx = self._reg2int(self.mmio.read(iop_const.MAILBOX_OFFSET))\\r\\n\\t\\tmy = self._reg2int(self.mmio.read(iop_const.MAILBOX_OFFSET+4))\\r\\n\\t\\tmz = self._reg2int(self.mmio.read(iop_const.MAILBOX_OFFSET+8))\\r\\n\\t\\treturn [float(\\\"{0:.2f}\\\".format(mx*0.004)),\\r\\n\\t\\t\\t\\tfloat(\\\"{0:.2f}\\\".format(my*0.004)),\\r\\n\\t\\t\\t\\tfloat(\\\"{0:.2f}\\\".format(mz*0.004))]\",\n \"def recv_data(self):\\n data = \\\"\\\"\\n size = 0\\n\\n try:\\n size = self.sockObj.recv(4) #Get metadata\\n except:\\n raise Exception(\\\"Error while receiving data. Probably broken pipe\\\")\\n\\n if len(size) == 0:\\n raise Exception(\\\"No data recivied. Probably broken pipe\\\")\\n\\n size = struct.unpack('>I',size)[0]\\n\\n data = self.sockObj.recv(size)\\n\\n if len(data) != size:\\n raise Exception(\\\"Partiala data recivied\\\")\\n\\n return self.decode(data)\",\n \"def get_data(self):\\n return {\\\"bcode\\\": self.barcode, \\\"prodid\\\": self.product_id}\",\n \"def _receive(self, what, address='localhost:502', **kwargs):\\n colon_index = address.find(':')\\n IP = '-i {} '.format(address[:colon_index])\\n PORT = '-p {} '.format(address[colon_index+1:])\\n # NOTE: following data is validated by client script\\n MODE = '-m {} '.format('r')\\n TYPE = '-t {} '.format(what[0])\\n OFFSET = '-o {} '.format(what[1]) # NOTE: 0-based\\n\\n # NOTE: kwargs\\n if 'count' in kwargs:\\n count = kwargs['count']\\n COUNT = '--count {} '.format(kwargs['count'])\\n else:\\n count = 1\\n COUNT = '--count {} '.format(1)\\n\\n cmd = shlex.split(\\n self._client_cmd +\\n IP +\\n PORT +\\n MODE +\\n TYPE +\\n OFFSET +\\n COUNT\\n )\\n # print 'DEBUG modbus_receive cmd shlex list: ', cmd\\n\\n try:\\n client = subprocess.Popen(cmd, shell=False,\\n stdout=subprocess.PIPE)\\n\\n # client.communicate is blocking\\n raw_out = client.communicate()\\n # print 'DEBUG modbus _receive raw_out: ', raw_out\\n\\n # value is stored as first tuple element\\n # between a pair of square brackets\\n raw_string = raw_out[0].strip()\\n\\n # NOTE: registers store int\\n if what[0] == 'HR' or what[0] == 'IR':\\n\\n # NOTE: single read returns an int\\n if count == 1:\\n out = int(raw_string[1:-1])\\n\\n # NOTE: multiple reads returns a list of ints\\n else:\\n out = []\\n hrs = raw_string[1:-1].split(',')\\n for hr in hrs:\\n out.append(int(hr))\\n if len(out) != count:\\n raise ValueError('Wrong number of values in the response.')\\n\\n # NOTE: coils and discrete inputs store 8 bools\\n elif what[0] == 'CO' or what[0] == 'DI':\\n # print 'DEBUG modbus _receive bools: ', bools\\n\\n # NOTE: pymodbus always returns at least a list of 8 bools\\n bools = raw_string[1:-1].split(',')\\n\\n # NOTE: single read returns a bool\\n if count == 1:\\n if bools[0] == 'False':\\n out = False\\n elif bools[0] == 'True':\\n out = True\\n else:\\n raise TypeError('CO or DI values must be bool.')\\n\\n # NOTE: multiple reads returns a list of bools\\n else:\\n out = []\\n i = 0\\n for b in bools:\\n if i >= count:\\n break\\n elif b.strip() == 'False':\\n out.append(False)\\n elif b.strip() == 'True':\\n out.append(True)\\n else:\\n raise TypeError('CO or DI values must be bool.')\\n i += 1\\n\\n return out\\n\\n except Exception as error:\\n print('ERROR modbus _receive: ', error)\",\n \"def fetch_data(self):\",\n \"def data(self):\\n return self._data\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66622156","0.6451813","0.6422266","0.6291614","0.62907284","0.6256919","0.6247429","0.61632484","0.61528784","0.61516654","0.6148364","0.60508144","0.6022441","0.6019723","0.60150313","0.6006078","0.6003648","0.5983829","0.59709984","0.596881","0.59405935","0.5928196","0.5912466","0.58841264","0.58710635","0.58599645","0.5849922","0.58236116","0.5813774","0.5807888","0.5788125","0.5753847","0.5752147","0.57456076","0.57432455","0.5730203","0.5727733","0.57224107","0.5719336","0.57031256","0.57008266","0.5685312","0.56740886","0.5667073","0.5667073","0.56665456","0.565907","0.5641553","0.56353194","0.5626437","0.5621432","0.56104356","0.5609679","0.5606383","0.56043","0.55959153","0.5594752","0.5584744","0.5581419","0.5574307","0.556118","0.55595684","0.55595684","0.5557937","0.55524933","0.5549199","0.55469006","0.55468065","0.552234","0.5517369","0.5517369","0.5504255","0.54859465","0.5483692","0.54811853","0.54759467","0.547124","0.54707867","0.54653597","0.5463456","0.5454881","0.545364","0.54521465","0.5438637","0.54325944","0.54325944","0.54324687","0.5432181","0.54261965","0.54261965","0.5422262","0.5419327","0.5418809","0.5416323","0.541249","0.5411777","0.5409752","0.54057026","0.5404736","0.54045486"],"string":"[\n \"0.66622156\",\n \"0.6451813\",\n \"0.6422266\",\n \"0.6291614\",\n \"0.62907284\",\n \"0.6256919\",\n \"0.6247429\",\n \"0.61632484\",\n \"0.61528784\",\n \"0.61516654\",\n \"0.6148364\",\n \"0.60508144\",\n \"0.6022441\",\n \"0.6019723\",\n \"0.60150313\",\n \"0.6006078\",\n \"0.6003648\",\n \"0.5983829\",\n \"0.59709984\",\n \"0.596881\",\n \"0.59405935\",\n \"0.5928196\",\n \"0.5912466\",\n \"0.58841264\",\n \"0.58710635\",\n \"0.58599645\",\n \"0.5849922\",\n \"0.58236116\",\n \"0.5813774\",\n \"0.5807888\",\n \"0.5788125\",\n \"0.5753847\",\n \"0.5752147\",\n \"0.57456076\",\n \"0.57432455\",\n \"0.5730203\",\n \"0.5727733\",\n \"0.57224107\",\n \"0.5719336\",\n \"0.57031256\",\n \"0.57008266\",\n \"0.5685312\",\n \"0.56740886\",\n \"0.5667073\",\n \"0.5667073\",\n \"0.56665456\",\n \"0.565907\",\n \"0.5641553\",\n \"0.56353194\",\n \"0.5626437\",\n \"0.5621432\",\n \"0.56104356\",\n \"0.5609679\",\n \"0.5606383\",\n \"0.56043\",\n \"0.55959153\",\n \"0.5594752\",\n \"0.5584744\",\n \"0.5581419\",\n \"0.5574307\",\n \"0.556118\",\n \"0.55595684\",\n \"0.55595684\",\n \"0.5557937\",\n \"0.55524933\",\n \"0.5549199\",\n \"0.55469006\",\n \"0.55468065\",\n \"0.552234\",\n \"0.5517369\",\n \"0.5517369\",\n \"0.5504255\",\n \"0.54859465\",\n \"0.5483692\",\n \"0.54811853\",\n \"0.54759467\",\n \"0.547124\",\n \"0.54707867\",\n \"0.54653597\",\n \"0.5463456\",\n \"0.5454881\",\n \"0.545364\",\n \"0.54521465\",\n \"0.5438637\",\n \"0.54325944\",\n \"0.54325944\",\n \"0.54324687\",\n \"0.5432181\",\n \"0.54261965\",\n \"0.54261965\",\n \"0.5422262\",\n \"0.5419327\",\n \"0.5418809\",\n \"0.5416323\",\n \"0.541249\",\n \"0.5411777\",\n \"0.5409752\",\n \"0.54057026\",\n \"0.5404736\",\n \"0.54045486\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.54014295"},"document_rank":{"kind":"string","value":"100"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":762,"numItemsPerPage":100,"numTotalItems":95772,"offset":76200,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjUyODk2NCwianRpIjoiZmQ5YjNlMzQtYmI0ZS00ZmZlLWE0YzMtN2E0ZDBkMTdhN2RjIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY1MzI1NjQsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.y5Dnvn-NibHWTYbmaglddugm5apdCEh-_7ke9D22v8dCp4yR-en9daYIarALk03z7UFJNJqfrICvWchal2YIAw","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 |
|---|---|---|---|---|---|---|
Integrate ODE with velocity verlet rule | def integrate_VV_one_step(self, h, m):
qs = np.array([planet.position[-1] for planet in self.planets]).flatten()
vs = np.array([planet.velocity[-1] for planet in self.planets]).flatten()
# Velocity verlet rule
q_new = qs + h*vs + 0.5*h**2*self.rhs(qs, m)
v_n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, timestep=1.0 * simtk.unit.femtoseconds):\n\n super(VelocityVerletIntegrator, self).__init__(timestep)\n\n self.addPerDofVariable(\"x1\", 0)\n\n self.addUpdateContextState()\n self.addComputePerDof(\"v\", \"v+0.5*dt*f/m\")\n self.addComputePerDof(\"x\", \"x+dt*v... | [
"0.69790566",
"0.69155824",
"0.67686814",
"0.676095",
"0.67001384",
"0.66451144",
"0.65395856",
"0.65192693",
"0.64639986",
"0.64069223",
"0.62580323",
"0.625561",
"0.6218177",
"0.6199242",
"0.6185856",
"0.61609584",
"0.61557555",
"0.6152949",
"0.6087269",
"0.6077202",
"0.607... | 0.6586397 | 6 |
performs evolution of gravitational problem by solving ODE System | def evolve(self, tEnd, nsteps):
tStart = self.timeline[-1]
m = [planet.mass for planet in self.planets]
h = (float(tEnd - tStart))/float(nsteps)
for i in range(nsteps):
self.integrate_VV_one_step(h, m)
self.timeline.append(tStart + (i+1)*h) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def call_odeint(particle_object,dt,omega):\n \n# print \n# print '##########################'\n# \n r = particle_object.position\n v = particle_object.velocity \n beta = particle_object.beta \n# \n# print 'Initial parameters'\n# print 'r', r\n# print 'v', v\n# print 'beta',beta\... | [
"0.7172907",
"0.646518",
"0.6415619",
"0.6383432",
"0.61928487",
"0.61663693",
"0.6134493",
"0.6088288",
"0.6077409",
"0.6022923",
"0.6007185",
"0.59988606",
"0.5998538",
"0.5997303",
"0.5994409",
"0.59925014",
"0.5991818",
"0.5969261",
"0.59685314",
"0.59635097",
"0.5961449"... | 0.0 | -1 |
updates position and velocity | def changeposvel(self, newpos, newvel):
self.position.append(newpos)
self.velocity.append(newvel) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_position(self):\n self.position[0] += self.velocity[0]\n self.position[1] += self.velocity[1]",
"def updatePos(self):\n self.timeDriving +=1\n self.pos[0] += self.vx\n self.pos[1] += self.vy",
"def update(self):\r\n # change in position -> velocity\r\n ... | [
"0.85512257",
"0.8209232",
"0.8162798",
"0.80040765",
"0.79971707",
"0.79405236",
"0.7837445",
"0.77498865",
"0.7737172",
"0.7632638",
"0.76268536",
"0.76204854",
"0.7579972",
"0.7482718",
"0.74079674",
"0.7392498",
"0.7346028",
"0.7342991",
"0.73272717",
"0.7303948",
"0.7298... | 0.6976005 | 49 |
outputs x positions as strin "[1.222, 1.2226, .. ]" | def x_as_plotly(self):
xs = np.asarray(self.position)[:,0]
return numpy_to_plotlystring(xs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vec_x(self):\t\r\n if self.ox != 0:\r\n ov = self.ox\r\n lv = self.self.lx + self.ox\r\n else:\r\n ov = self.dx / 2\r\n lv = self.lx\r\n\r\n xv = \"\"\r\n for num in np.arange(ov, lv, self.dx):\r\n xv += str(num) + \" \"\r\n\r\n... | [
"0.71450645",
"0.6810249",
"0.6673763",
"0.6567991",
"0.6540675",
"0.63349146",
"0.6268591",
"0.6193773",
"0.6130126",
"0.61087924",
"0.6093594",
"0.60668325",
"0.60067976",
"0.60057795",
"0.60003287",
"0.59720314",
"0.5943515",
"0.5881741",
"0.58783597",
"0.58677405",
"0.585... | 0.6141436 | 8 |
outputs x positions as strin "[1.222, 1.2226, .. ]" | def y_as_plotly(self):
xs = np.asarray(self.position)[:,1]
return numpy_to_plotlystring(xs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vec_x(self):\t\r\n if self.ox != 0:\r\n ov = self.ox\r\n lv = self.self.lx + self.ox\r\n else:\r\n ov = self.dx / 2\r\n lv = self.lx\r\n\r\n xv = \"\"\r\n for num in np.arange(ov, lv, self.dx):\r\n xv += str(num) + \" \"\r\n\r\n... | [
"0.71444696",
"0.68112135",
"0.6672699",
"0.6567815",
"0.65418977",
"0.63358814",
"0.6268534",
"0.6194604",
"0.6141355",
"0.6130819",
"0.6109853",
"0.6095049",
"0.6068203",
"0.60069877",
"0.6006738",
"0.60013515",
"0.5972044",
"0.5944388",
"0.58800787",
"0.58775926",
"0.58673... | 0.0 | -1 |
outputs x positions as strin "[1.222, 1.2226, .. ]" | def z_as_plotly(self):
xs = np.asarray(self.position)[:,2]
return numpy_to_plotlystring(xs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vec_x(self):\t\r\n if self.ox != 0:\r\n ov = self.ox\r\n lv = self.self.lx + self.ox\r\n else:\r\n ov = self.dx / 2\r\n lv = self.lx\r\n\r\n xv = \"\"\r\n for num in np.arange(ov, lv, self.dx):\r\n xv += str(num) + \" \"\r\n\r\n... | [
"0.71450645",
"0.6810249",
"0.6673763",
"0.6567991",
"0.6540675",
"0.63349146",
"0.6268591",
"0.6193773",
"0.6141436",
"0.6130126",
"0.61087924",
"0.6093594",
"0.60668325",
"0.60067976",
"0.60057795",
"0.60003287",
"0.59720314",
"0.5943515",
"0.5881741",
"0.58783597",
"0.5867... | 0.0 | -1 |
Figure out how 'stealable' a product is. | def stealability(self):
value_weight_ratio = self.price / self.weight
if value_weight_ratio < 0.5:
return 'Not so stealable...'
elif value_weight_ratio < 1.0:
return 'Kinda stealable.'
else:
return 'Very stealable!' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_stealable(self):\r\n prod = Product(name='Test Product',\r\n weight=100, price=1,\r\n flammability=0.5)\r\n self.assertEqual(prod.stealability(), \"Not so stealable...\")",
"def get_product_purity(product):\n return product.imass[products].sum... | [
"0.7068694",
"0.68756706",
"0.6865457",
"0.68567866",
"0.6746189",
"0.67266905",
"0.6655292",
"0.6651548",
"0.5973055",
"0.591588",
"0.58441055",
"0.58441055",
"0.5834489",
"0.58047146",
"0.5793756",
"0.5649274",
"0.55833334",
"0.55405885",
"0.55398786",
"0.5513801",
"0.55071... | 0.6795847 | 4 |
Destroy products if they have a potency 10 or over | def explode(self):
potency = self.flammability * self.weight
if potency < 10:
return '...fizzle.'
elif potency < 50:
return '...boom!'
else:
return '...BABOOM!!' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_03_product_delete(self):\n product = self.create_product()\n products = self.product_obj.search([])\n self.assertIn(product, products)\n product.unlink()\n self.assertNotIn(product.exists(), products)",
"def destroy(self, good, quantity=None):\n if quantity is N... | [
"0.62185144",
"0.59200734",
"0.572847",
"0.5650125",
"0.5647066",
"0.5629055",
"0.5602103",
"0.55858773",
"0.55444473",
"0.55411506",
"0.5466819",
"0.5395617",
"0.53691226",
"0.53192776",
"0.5294266",
"0.52941823",
"0.5286533",
"0.5273428",
"0.52670205",
"0.52670205",
"0.5259... | 0.0 | -1 |
The main purpose of a boxing glove. | def punch(self):
if self.weight < 5:
return "That tickles."
elif self.weight < 15:
return "Hey that hurt!"
else:
return "OUCH!" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def box(self, x, y, w, h):\n\t\tpass",
"def test_default_boxing_glove_weight(self):\n glove = BoxingGlove('Test Boxing Glove')\n self.assertEqual(glove.weight, 10)",
"def test_box_shoot():\n rng = galsim.BaseDeviate(1234)\n obj = galsim.Box(width=1.3, height=2.4, flux=1.e4)\n im = galsim... | [
"0.6335239",
"0.62205344",
"0.5916162",
"0.58255595",
"0.58229667",
"0.58111346",
"0.57119113",
"0.5704412",
"0.5701285",
"0.565995",
"0.56531554",
"0.5649582",
"0.5586943",
"0.556026",
"0.5521398",
"0.5511402",
"0.550355",
"0.5497406",
"0.5493279",
"0.54882395",
"0.5483882",... | 0.0 | -1 |
Initiate the class by the file path. | def __init__(self, path):
self.path = path
self.stat = os.stat(path)
self.timestamp = self.stat.st_mtime
self.datetime = datetime.fromtimestamp(self.timestamp)
self.modified_at = self.datetime.strftime(ISOFORMAT)
self.hash = self._get_hash(path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, path_to_the_file):",
"def __init__(self, path_to_the_file):",
"def __init__(self, path=None):\n pass",
"def __init__(self, path):\n self.path = path",
"def __init__(self, path):\n self.path = path",
"def __init__(self, path):\n self.path = path",
"def __in... | [
"0.7629349",
"0.7629349",
"0.7264906",
"0.7259031",
"0.7259031",
"0.7259031",
"0.7259031",
"0.71294206",
"0.707562",
"0.7073415",
"0.70441884",
"0.6974368",
"0.6956341",
"0.6928309",
"0.68991226",
"0.679767",
"0.6743757",
"0.6643421",
"0.6632877",
"0.6632012",
"0.65475446",
... | 0.0 | -1 |
Generate a hash from a path. | def _get_hash(self, path):
with open(path, "r") as fp:
content = fp.read()
return sha256(content).hexdigest() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_hash(path: Path) -> str:\n m = hashlib.sha256()\n m.update(path.read_bytes())\n return m.hexdigest()",
"def hash(path):\n\n with open(path, 'r') as file:\n return hashlib.sha1(file.read()).hexdigest()",
"def hash_file(path: str) -> str:\n return _hash_file(path, hashlib.md5()).hex... | [
"0.8353133",
"0.79902816",
"0.7831256",
"0.75318193",
"0.73715246",
"0.73625535",
"0.73011464",
"0.72034276",
"0.7094866",
"0.70322156",
"0.7031676",
"0.6988874",
"0.697214",
"0.6966215",
"0.6926758",
"0.6904041",
"0.6845439",
"0.6797321",
"0.67444646",
"0.6710574",
"0.669085... | 0.7663555 | 3 |
Verify if a file is equal or different from another file. | def __eq__(self, other):
if (self.timestamp == other.timestamp) and (self.hash == other.hash):
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def are_files_equal(file1, file2):\n input_file_1 = open(file1, \"r\")\n input_file_2 = open(file2, \"r\")\n\n file1 = input_file_1.read()\n file2 = input_file_2.read()\n print(type(file1), file1, type(file2), file2)\n\n result =False\n if file1 == file1:\n result = True\n\n input_fi... | [
"0.82369065",
"0.8006959",
"0.76935977",
"0.7641318",
"0.76184404",
"0.75801724",
"0.7558758",
"0.755381",
"0.75402236",
"0.7494288",
"0.7491777",
"0.7351352",
"0.7313978",
"0.7262525",
"0.72543037",
"0.72270894",
"0.7206164",
"0.7196517",
"0.7137066",
"0.7131839",
"0.7044682... | 0.0 | -1 |
Verify if a new file is different froma another file. | def __ne__(self, other):
if (self.timestamp != other.timestamp) and (self.hash != other.hash):
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_duplicate(fp1, fp2):\n try:\n subprocess.check_output(['diff', fp1, fp2])\n return True\n except subprocess.CalledProcessError:\n return False",
"def test_new_file_diff(self):\n diff = (\n b'diff --git a/IAMNEW b/IAMNEW\\n'\n b'new file mode 100644\\n'\n ... | [
"0.74250644",
"0.7307473",
"0.72700745",
"0.72628975",
"0.7191385",
"0.718327",
"0.71489614",
"0.71243423",
"0.707887",
"0.6985169",
"0.69682914",
"0.6959802",
"0.6910966",
"0.68806756",
"0.6812512",
"0.67898667",
"0.6786714",
"0.67848563",
"0.67508864",
"0.6724743",
"0.67231... | 0.0 | -1 |
Return the official string representation of the object. | def __repr__(self):
return "<FileItem path='{0}'>".format(self.path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n return str(self.__dict__['_obj'])",
"def to_string(self):\r\n return self.__str__()",
"def toString(self) -> str:\n raise NotImplementedError",
"def __str__(self):\n return str(self.obj)",
"def get_str(self, obj):\n if self.pretty:\n ... | [
"0.79084724",
"0.77594864",
"0.7741893",
"0.773866",
"0.770523",
"0.7658698",
"0.76131463",
"0.76131463",
"0.7573172",
"0.75557417",
"0.7535943",
"0.7528846",
"0.75268936",
"0.7526087",
"0.7498243",
"0.7497394",
"0.7442554",
"0.74345976",
"0.74343866",
"0.74243754",
"0.739801... | 0.0 | -1 |
Initializes the position of the pieces on the board (x, y), color of piece (color), and if it is on the board (True or False). | def __init__(self, color):
self._color = color # Color redefined when placed
# Palace coords
self._d = ['d1','d2','d3','d8','d9','d10']
self._e = ['e1','e2','e3','e8','e9','e10']
self._f = ['f1','f2','f3','f8','f9','f10']
self._special = self._d + self._f + self._e
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize_board(self):\n self.board = np.zeros(shape=(BOARD_SIZE, BOARD_SIZE), dtype=np.int) # another way of defining board: [[for x in range(cm.BOARD_SIZE)] for x in range(cm.BOARD_SIZE)]\n center = int(BOARD_SIZE / 2)\n self.board[center-1][center-1] = self.board[center][center] = WH... | [
"0.70904624",
"0.6952656",
"0.6930828",
"0.68304855",
"0.68072546",
"0.6751505",
"0.6677907",
"0.666762",
"0.6638752",
"0.6597177",
"0.65884244",
"0.65839565",
"0.6566997",
"0.6516349",
"0.65150744",
"0.6497887",
"0.6476026",
"0.647289",
"0.64177",
"0.6414555",
"0.6397623",
... | 0.0 | -1 |
Returns the type of piece in a position on the board | def piece_type(self, pos, board):
piece = board[self.ind(pos)[0]][self.ind(pos)[1]]
return piece | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_piece_type(self, pos):\n piece = self.get_board()[self.ind(pos)[0]][self.ind(pos)[1]]\n return piece",
"def piece_type(self):\n return self._piece_type",
"def piece_type(self):\n return self._piece_type",
"def piece_type(self):\n return self._piece_type",
"def pie... | [
"0.86817193",
"0.7477756",
"0.7477756",
"0.7477756",
"0.7477756",
"0.7477756",
"0.7477756",
"0.74554956",
"0.7289101",
"0.72572297",
"0.69393",
"0.6906759",
"0.66416234",
"0.6636054",
"0.6636054",
"0.66352475",
"0.66080254",
"0.66080254",
"0.66034764",
"0.6596245",
"0.6439447... | 0.8838244 | 0 |
Returns the color of the piece | def get_color(self):
return self._color | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def color(piece):\n return Color.BLACK if piece in {Piece.BP, Piece.BN, Piece.BB, Piece.BR, Piece.BQ, Piece.BK} else Color.WHITE",
"def piece_color(self, piece):\n if piece == None:\n return None\n if ord(ChessPiece.W_KING) <= ord(piece) <= ord(ChessPiece.W_PAWN):\n ret... | [
"0.7939147",
"0.7717077",
"0.7684216",
"0.76383805",
"0.7632601",
"0.7610868",
"0.7576671",
"0.7567566",
"0.7567566",
"0.7567566",
"0.7567566",
"0.7528468",
"0.75168306",
"0.7486091",
"0.74580204",
"0.7429947",
"0.7415221",
"0.7405115",
"0.73971117",
"0.7374749",
"0.7362447",... | 0.7503997 | 14 |
Converts the string input to an easier index for the board | def ind(self, pos):
row = int(pos[1:]) - 1
column = self.letter_to_column(pos[0])
return row, column | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def str_to_tile_index(s, index_of_a = 0xe6, index_of_zero = 0xdb, special_cases = None):\n\n\tres = []\n\tfor c in s:\n\t\tindex = None\n\t\tif ord(c) >= ord('a') and ord(c) <= ord('z'):\n\t\t\tindex = ord(c) - ord('a') + index_of_a\n\t\telif ord(c) >= ord('A') and ord(c) <= ord('Z'):\n\t\t\tindex = ord(c) - ord('... | [
"0.6576328",
"0.6363488",
"0.624561",
"0.624561",
"0.6237214",
"0.62040347",
"0.6185074",
"0.61043257",
"0.606646",
"0.5939117",
"0.5930663",
"0.5908649",
"0.58882946",
"0.5851099",
"0.5829864",
"0.580793",
"0.5769647",
"0.57682794",
"0.57541066",
"0.57187545",
"0.5717817",
... | 0.0 | -1 |
Method to convert string letters of columns to int to index | def letter_to_column(self, pos):
column_dict = {}
column_dict['a'] = 0
column_dict['b'] = 1
column_dict['c'] = 2
column_dict['d'] = 3
column_dict['e'] = 4
column_dict['f'] = 5
column_dict['g'] = 6
column_dict['h'] = 7
column_dict['i'] = 8
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def toindex(col, row):\n a2z = 'ABCDEFGHIJLKMNOPQRSTUVWXYZ'\n\n total = 0\n mult = 0\n for char in col:\n total += (a2z.find(char) + (26 * mult))\n mult += 1\n\n return total, row - 1",
"def _index_to_column(i, column=''):\n\n # A dictionary of numbers to letters starting at 0, e.... | [
"0.697564",
"0.6872223",
"0.6809196",
"0.6733294",
"0.670394",
"0.66991305",
"0.659503",
"0.6433898",
"0.6289558",
"0.6243379",
"0.62226945",
"0.616821",
"0.61548716",
"0.61546075",
"0.6106652",
"0.60687786",
"0.60532284",
"0.6017571",
"0.5993722",
"0.5990299",
"0.5941516",
... | 0.59708834 | 20 |
A check to see if the general can still make moves | def check_general(self, gb, gr):
gb = General("BLUE")
gr = General("RED")
# Look to see if the generals are in the same column
gr_row = self.ind(new_pos)[0]
gr_col = self.ind(new_pos)[1]
gb_row = self.ind(cur_pos)[0]
gb_col = self.ind(cur_pos)[1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move_check(self):\r\n \r\n if not self.run:\r\n return False\r\n \r\n if self.get_num_legal_moves() == 0:\r\n SlTrace.lg(\"NO more legal moves!\", \"nolegalmoves\")\r\n ###return False \r\n \r\n if self.new_move:\r\n se... | [
"0.74166924",
"0.740076",
"0.737363",
"0.73624766",
"0.71835196",
"0.7156893",
"0.71426195",
"0.7047893",
"0.7012101",
"0.6978454",
"0.69773424",
"0.69601774",
"0.6956621",
"0.6950494",
"0.69336253",
"0.69222677",
"0.69169897",
"0.68975604",
"0.6894488",
"0.6885957",
"0.68812... | 0.0 | -1 |
Initializes the General object | def __init__(self, color):
super().__init__(color) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def initialize(self):\n\t\tpass",
... | [
"0.765378",
"0.765378",
"0.765378",
"0.765378",
"0.765378",
"0.765378",
"0.765378",
"0.765378",
"0.7540846",
"0.7486289",
"0.74687177",
"0.74687177",
"0.74307793",
"0.74307793",
"0.74307793",
"0.74307793",
"0.74307793",
"0.73436445",
"0.73008484",
"0.72553277",
"0.72162044",
... | 0.0 | -1 |
Returns whether or not moving a piece to a desired position is a legal move. | def check_legal(self, cur_pos, new_pos, board, state):
if cur_pos and new_pos in self._special:
new_row = self.ind(new_pos)[0]
new_col = self.ind(new_pos)[1]
cur_row = self.ind(cur_pos)[0]
cur_col = self.ind(cur_pos)[1]
if state == "UNFINISHED"... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_legal_move(self, current_player, move):\n\t\tstarting_pos = move[0]\n\t\tending_pos = move[1]\n\t\tif ending_pos[0] not in range(self.board_size) or ending_pos[1] not in range(self.board_size):\t# Discard any generated moves that fall off of the board\n\t\t\treturn False \n\t\tif self.board.repr[starting_... | [
"0.80670345",
"0.7887482",
"0.7804901",
"0.7694283",
"0.76606935",
"0.7650084",
"0.7638945",
"0.7626525",
"0.7550252",
"0.75415576",
"0.7538948",
"0.7497688",
"0.7491545",
"0.7488044",
"0.74343395",
"0.74303377",
"0.74189925",
"0.741797",
"0.7385709",
"0.73738515",
"0.7362131... | 0.74184275 | 17 |
Initializes the Guard object | def __init__(self, color):
super().__init__(color) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n\n self._authorize()",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\... | [
"0.66751796",
"0.6549449",
"0.6549449",
"0.6549449",
"0.6549449",
"0.6549449",
"0.6549449",
"0.6549449",
"0.6549449",
"0.65249234",
"0.65249234",
"0.65249234",
"0.65249234",
"0.65249234",
"0.65057564",
"0.65057564",
"0.65014035",
"0.64822745",
"0.64812714",
"0.647015",
"0.647... | 0.0 | -1 |
Returns whether or not moving a piece to a desired position is a legal move. | def check_legal(self, cur_pos, new_pos, board, state):
if cur_pos and new_pos in self._special:
new_row = self.ind(new_pos)[0]
new_col = self.ind(new_pos)[1]
cur_row = self.ind(cur_pos)[0]
cur_col = self.ind(cur_pos)[1]
if state == "UNFINISHED":
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_legal_move(self, current_player, move):\n\t\tstarting_pos = move[0]\n\t\tending_pos = move[1]\n\t\tif ending_pos[0] not in range(self.board_size) or ending_pos[1] not in range(self.board_size):\t# Discard any generated moves that fall off of the board\n\t\t\treturn False \n\t\tif self.board.repr[starting_... | [
"0.80670345",
"0.7887482",
"0.7804901",
"0.7694283",
"0.76606935",
"0.7650084",
"0.7638945",
"0.7626525",
"0.7550252",
"0.75415576",
"0.7538948",
"0.7497688",
"0.7491545",
"0.7488044",
"0.74343395",
"0.74303377",
"0.74189925",
"0.74184275",
"0.741797",
"0.73738515",
"0.736213... | 0.7385709 | 19 |
Initializes the Horse object | def __init__(self, color):
super().__init__(color) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize(self):\n\n # --------- BEGIN YOUR CODE ----------\n\n # This is exactly the same as Human.initialize, just copy the code over\n\n # --------- END YOUR CODE ----------\n pass",
"def __init__(self):\n\t\tself.hog = cv2.HOGDescriptor()\n\t\tself.hog.setSVMDetector(cv2.HOGD... | [
"0.62536705",
"0.6193872",
"0.59844786",
"0.59842765",
"0.5983944",
"0.5982943",
"0.5981144",
"0.5977151",
"0.5969011",
"0.5948414",
"0.5927264",
"0.59155196",
"0.5910404",
"0.58812",
"0.5878882",
"0.58774865",
"0.5867995",
"0.5852446",
"0.5848517",
"0.5822541",
"0.58182365",... | 0.0 | -1 |
Returns whether or not moving a piece to a desired position is a legal move. | def check_legal(self, cur_pos, new_pos, board, state):
new_row = self.ind(new_pos)[0]
new_col = self.ind(new_pos)[1]
cur_row = self.ind(cur_pos)[0]
cur_col = self.ind(cur_pos)[1]
piece = self.piece_type(cur_pos, board)
if state == "UNFINISHED":
# Check if the mo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_legal_move(self, current_player, move):\n\t\tstarting_pos = move[0]\n\t\tending_pos = move[1]\n\t\tif ending_pos[0] not in range(self.board_size) or ending_pos[1] not in range(self.board_size):\t# Discard any generated moves that fall off of the board\n\t\t\treturn False \n\t\tif self.board.repr[starting_... | [
"0.80670345",
"0.7887482",
"0.7804901",
"0.7694283",
"0.76606935",
"0.7650084",
"0.7638945",
"0.7626525",
"0.7550252",
"0.75415576",
"0.7538948",
"0.7497688",
"0.7491545",
"0.7488044",
"0.74343395",
"0.74303377",
"0.74189925",
"0.74184275",
"0.741797",
"0.7385709",
"0.7373851... | 0.71017843 | 41 |
Initializes the Elephant object | def __init__(self, color):
super().__init__(color) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize(self):\n\n # --------- BEGIN YOUR CODE ----------\n\n # This is exactly the same as Human.initialize, just copy the code over\n\n # --------- END YOUR CODE ----------\n pass",
"def setup(self):\n self.ae = None",
"def __init__(self, bee):\n self.id = Bee... | [
"0.6365033",
"0.6240697",
"0.6126713",
"0.6047953",
"0.6047953",
"0.6047953",
"0.6047953",
"0.6047953",
"0.6047953",
"0.6047953",
"0.6047953",
"0.60300183",
"0.6027994",
"0.60207295",
"0.6016816",
"0.6010854",
"0.5991587",
"0.5991587",
"0.5991587",
"0.5991587",
"0.5991587",
... | 0.0 | -1 |
Returns whether or not moving a piece to a desired position is a legal move. | def check_legal(self, cur_pos, new_pos, board, state):
new_row = self.ind(new_pos)[0]
new_col = self.ind(new_pos)[1]
cur_row = self.ind(cur_pos)[0]
cur_col = self.ind(cur_pos)[1]
piece = self.piece_type(cur_pos, board)
if state == "UNFINISHED":
if (new_row ==... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_legal_move(self, current_player, move):\n\t\tstarting_pos = move[0]\n\t\tending_pos = move[1]\n\t\tif ending_pos[0] not in range(self.board_size) or ending_pos[1] not in range(self.board_size):\t# Discard any generated moves that fall off of the board\n\t\t\treturn False \n\t\tif self.board.repr[starting_... | [
"0.80670345",
"0.7887482",
"0.7804901",
"0.7694283",
"0.76606935",
"0.7650084",
"0.7638945",
"0.7626525",
"0.7550252",
"0.75415576",
"0.7538948",
"0.7497688",
"0.7491545",
"0.7488044",
"0.74343395",
"0.74303377",
"0.74189925",
"0.74184275",
"0.741797",
"0.7385709",
"0.7373851... | 0.6890454 | 65 |
Initializes the Chariot object | def __init__(self, color):
super().__init__(color) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _initialize(self):\n self.send_init_command()",
"def init(self) -> None:\n ...",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"def init(self):\n pass",
"d... | [
"0.7165378",
"0.7119273",
"0.71136373",
"0.71136373",
"0.71136373",
"0.71136373",
"0.71136373",
"0.71136373",
"0.71136373",
"0.71136373",
"0.70866865",
"0.70866865",
"0.70866865",
"0.70866865",
"0.70866865",
"0.70742416",
"0.70396006",
"0.7035639",
"0.7035639",
"0.6998097",
"... | 0.0 | -1 |
Returns whether or not moving a piece to a desired position is a legal move. | def check_path(self, cur_pos, new_pos, board, state):
new_row = self.ind(new_pos)[0]
new_col = self.ind(new_pos)[1]
cur_row = self.ind(cur_pos)[0]
cur_col = self.ind(cur_pos)[1]
cannon_pieces = [Cannon('BLUE'), Cannon('RED')]
# Ensures the range is always in the... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_legal_move(self, current_player, move):\n\t\tstarting_pos = move[0]\n\t\tending_pos = move[1]\n\t\tif ending_pos[0] not in range(self.board_size) or ending_pos[1] not in range(self.board_size):\t# Discard any generated moves that fall off of the board\n\t\t\treturn False \n\t\tif self.board.repr[starting_... | [
"0.80670345",
"0.7887482",
"0.7804901",
"0.7694283",
"0.76606935",
"0.7650084",
"0.7638945",
"0.7626525",
"0.7550252",
"0.75415576",
"0.7538948",
"0.7497688",
"0.7491545",
"0.7488044",
"0.74343395",
"0.74303377",
"0.74189925",
"0.74184275",
"0.741797",
"0.7385709",
"0.7373851... | 0.0 | -1 |
Returns whether or not moving a piece to a desired position is a legal move. | def check_legal(self, cur_pos, new_pos, board, state):
new_row = self.ind(new_pos)[0]
new_col = self.ind(new_pos)[1]
cur_row = self.ind(cur_pos)[0]
cur_col = self.ind(cur_pos)[1]
if state == "UNFINISHED":
# Make sure the position you're going into isn't your own piece
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_legal_move(self, current_player, move):\n\t\tstarting_pos = move[0]\n\t\tending_pos = move[1]\n\t\tif ending_pos[0] not in range(self.board_size) or ending_pos[1] not in range(self.board_size):\t# Discard any generated moves that fall off of the board\n\t\t\treturn False \n\t\tif self.board.repr[starting_... | [
"0.806804",
"0.7886987",
"0.7805555",
"0.7694613",
"0.76609105",
"0.76509035",
"0.7638461",
"0.7627283",
"0.7551364",
"0.7542628",
"0.75390583",
"0.74978685",
"0.7492485",
"0.74871546",
"0.74348223",
"0.743149",
"0.7419824",
"0.741848",
"0.74178165",
"0.73851764",
"0.737407",... | 0.69577366 | 56 |
Initializes the Cannon object | def __init__(self, color):
super().__init__(color) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self.dna = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"def __init__(self):\n self.screen = pg.display.get_surface()\n self.screen_rect = self.screen.get_rect()\n self.joys = initialize_all_gamepads()\n self.done = False\n self.clock = pg.tim... | [
"0.6676756",
"0.66760147",
"0.6470259",
"0.64511144",
"0.64349926",
"0.63484627",
"0.6214447",
"0.6211741",
"0.61788964",
"0.6160442",
"0.6149705",
"0.6126983",
"0.61217487",
"0.6110981",
"0.61099446",
"0.609572",
"0.6090035",
"0.608955",
"0.608861",
"0.6083246",
"0.6064265",... | 0.0 | -1 |
Returns whether or not moving a piece to a desired position is a legal move. | def check_legal(self, cur_pos, new_pos, board, state):
print("we are in check legal???")
new_row = self.ind(new_pos)[0]
new_col = self.ind(new_pos)[1]
cur_row = self.ind(cur_pos)[0]
cur_col = self.ind(cur_pos)[1]
cannon_pieces = [Cannon('BLUE'), Cannon('RED')]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_legal_move(self, current_player, move):\n\t\tstarting_pos = move[0]\n\t\tending_pos = move[1]\n\t\tif ending_pos[0] not in range(self.board_size) or ending_pos[1] not in range(self.board_size):\t# Discard any generated moves that fall off of the board\n\t\t\treturn False \n\t\tif self.board.repr[starting_... | [
"0.80669796",
"0.7887585",
"0.78052557",
"0.76942205",
"0.7660359",
"0.764954",
"0.7639212",
"0.7626182",
"0.7550657",
"0.7541531",
"0.7539006",
"0.7497845",
"0.7491266",
"0.7487243",
"0.74339044",
"0.74294484",
"0.7418835",
"0.7418604",
"0.7417427",
"0.7384702",
"0.7373439",... | 0.6782942 | 77 |
Initializes the Soldier object | def __init__(self, color):
super().__init__(color) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUp(self):\n\n self.sold = Soldier(0, 0)\n self.R = Random(seed)",
"def __init__(self):\n self.x_coord = default_init\n self.y_coord = default_init\n self._init_random_coord() # generating random coordinates\n self.x_speed = default_init\n self.y_speed = de... | [
"0.7056018",
"0.67353684",
"0.6601777",
"0.65038085",
"0.6429334",
"0.63965416",
"0.6358217",
"0.63580596",
"0.63155276",
"0.62712073",
"0.6229866",
"0.62221044",
"0.62221044",
"0.62221044",
"0.62221044",
"0.62221044",
"0.62221044",
"0.62221044",
"0.62221044",
"0.6212346",
"0... | 0.0 | -1 |
Returns whether or not moving a piece to a desired position is a legal move. | def check_legal(self, cur_pos, new_pos, board, state):
new_row = self.ind(new_pos)[0]
new_col = self.ind(new_pos)[1]
cur_row = self.ind(cur_pos)[0]
cur_col = self.ind(cur_pos)[1]
if state == "UNFINISHED":
# Make sure the position you're going into isn't your own ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_legal_move(self, current_player, move):\n\t\tstarting_pos = move[0]\n\t\tending_pos = move[1]\n\t\tif ending_pos[0] not in range(self.board_size) or ending_pos[1] not in range(self.board_size):\t# Discard any generated moves that fall off of the board\n\t\t\treturn False \n\t\tif self.board.repr[starting_... | [
"0.806804",
"0.7886987",
"0.7805555",
"0.7694613",
"0.76609105",
"0.76509035",
"0.7638461",
"0.7627283",
"0.7551364",
"0.7542628",
"0.75390583",
"0.74978685",
"0.7492485",
"0.74348223",
"0.743149",
"0.7419824",
"0.741848",
"0.74178165",
"0.73851764",
"0.737407",
"0.736229",
... | 0.74871546 | 13 |
Builds the board and places the pieces in its spots | def __init__(self):
self._board = []
for i in range(10):
self._board.append([None for i in range(9)])
self.place_pieces() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_pieces(self):\n\n for i in range(len(self._game_board)):\n\n # Row 1\n if i == 0:\n for ii in range(len(self._game_board[i])):\n if ii == 0 or ii == 8:\n self._game_board[i][ii] = Chariot(\"black\", \"BCHA\")\n ... | [
"0.76958317",
"0.75001955",
"0.74567485",
"0.7341733",
"0.70812273",
"0.7060305",
"0.7044529",
"0.703703",
"0.7003849",
"0.70005375",
"0.6979452",
"0.6912584",
"0.6899879",
"0.6873802",
"0.68558186",
"0.68404317",
"0.68015313",
"0.6734895",
"0.67268836",
"0.6687073",
"0.66094... | 0.7115662 | 4 |
pos is a string of a letter (column) and a number (row) for example pos = 'a2' which is the first column in the second row | def add_piece(self, pos, piece):
self._board[self.ind(pos)[0]][self.ind(pos)[1]] = piece | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_pos(self, pos):\r\n\r\n column = ord(pos[0]) - 97\r\n if len(pos) == 2:\r\n row = ord(pos[1]) - 49\r\n else:\r\n row = 9\r\n return [row, column]",
"def ind(self, pos):\n row = int(pos[1:]) - 1\n column = self.letter_to_column(pos[0])\n ... | [
"0.77553797",
"0.76948345",
"0.76948345",
"0.76948345",
"0.7183702",
"0.6877627",
"0.681922",
"0.6784532",
"0.6784532",
"0.6784532",
"0.6606381",
"0.65445465",
"0.6504546",
"0.64573586",
"0.6438382",
"0.63509005",
"0.6310229",
"0.6288248",
"0.6281679",
"0.62796885",
"0.626522... | 0.0 | -1 |
Places the pieces into the board | def place_pieces(self):
# Soldiers
# RED
self.add_piece('a4', Soldier('RED'))
self.add_piece('c4', Soldier('RED'))
self.add_piece('e4', Soldier('RED'))
self.add_piece('g4', Soldier('RED'))
self.add_piece('i4', Soldier('RED'))
# BLUE
self.ad... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_pieces(self):\n\n for i in range(len(self._game_board)):\n\n # Row 1\n if i == 0:\n for ii in range(len(self._game_board[i])):\n if ii == 0 or ii == 8:\n self._game_board[i][ii] = Chariot(\"black\", \"BCHA\")\n ... | [
"0.7959982",
"0.749098",
"0.734272",
"0.72255486",
"0.71461445",
"0.71421164",
"0.7104146",
"0.7104122",
"0.7098994",
"0.7047633",
"0.6989514",
"0.6965336",
"0.69504815",
"0.6940305",
"0.691998",
"0.6877462",
"0.6824572",
"0.682331",
"0.678611",
"0.676654",
"0.6737048",
"0.... | 0.72615147 | 3 |
Converts the string input to an easier index for the board | def ind(self, pos):
row = int(pos[1:]) - 1
column = self.letter_to_column(pos[0])
return row, column | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def str_to_tile_index(s, index_of_a = 0xe6, index_of_zero = 0xdb, special_cases = None):\n\n\tres = []\n\tfor c in s:\n\t\tindex = None\n\t\tif ord(c) >= ord('a') and ord(c) <= ord('z'):\n\t\t\tindex = ord(c) - ord('a') + index_of_a\n\t\telif ord(c) >= ord('A') and ord(c) <= ord('Z'):\n\t\t\tindex = ord(c) - ord('... | [
"0.65749663",
"0.63636225",
"0.6246017",
"0.6246017",
"0.6236835",
"0.620381",
"0.6185024",
"0.6103975",
"0.60677254",
"0.5938762",
"0.59301907",
"0.5907308",
"0.58895487",
"0.58494514",
"0.58299446",
"0.58082986",
"0.57690984",
"0.5768399",
"0.5753516",
"0.57182777",
"0.5717... | 0.0 | -1 |
Method to convert string letters of columns to int to index | def letter_to_column(self, pos):
column_dict = {}
column_dict['a'] = 0
column_dict['b'] = 1
column_dict['c'] = 2
column_dict['d'] = 3
column_dict['e'] = 4
column_dict['f'] = 5
column_dict['g'] = 6
column_dict['h'] = 7
column_dict['i'] = 8
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def toindex(col, row):\n a2z = 'ABCDEFGHIJLKMNOPQRSTUVWXYZ'\n\n total = 0\n mult = 0\n for char in col:\n total += (a2z.find(char) + (26 * mult))\n mult += 1\n\n return total, row - 1",
"def _index_to_column(i, column=''):\n\n # A dictionary of numbers to letters starting at 0, e.... | [
"0.69773763",
"0.68732166",
"0.68112355",
"0.6735234",
"0.6705109",
"0.669631",
"0.65928155",
"0.6434589",
"0.62909186",
"0.6246335",
"0.62254184",
"0.6169324",
"0.61528987",
"0.615157",
"0.6108927",
"0.60706455",
"0.60536516",
"0.6016396",
"0.5995302",
"0.5989416",
"0.593823... | 0.5971387 | 21 |
Initializes the JanggiGame object and any data members within it Will also initialize the board and the state of the game | def __init__(self):
self._current_state = "UNFINISHED"
self._start_color = "RED"
self._board = Board() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n\n super().__init__()\n self.setup_janggi_game()\n self._game_state = 'UNFINISHED'\n self._player_turn = 'BLUE'",
"def __init__(self):\n self._game_state = \"UNFINISHED\"\n self._current_player = \"BLACK\"\n self._game_board = Board()",
"def... | [
"0.76960254",
"0.75917774",
"0.7335311",
"0.7320754",
"0.72306293",
"0.7104167",
"0.70632404",
"0.7060205",
"0.70424086",
"0.6992594",
"0.69829863",
"0.69746006",
"0.69513136",
"0.6912526",
"0.6892557",
"0.68804467",
"0.68785805",
"0.6833406",
"0.6831556",
"0.68277174",
"0.68... | 0.69185317 | 13 |
Returns the current state of the game | def get_current_state(self):
return self._current_state | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_game_state(self):\n return self._current_state",
"def get_current_state(self):\n return self.game.get_current_state()",
"def get_game_state(self):\n return self.game_state",
"def get_game_state(self):\r\n return self._game_state",
"def game_state(self):\n return s... | [
"0.8688084",
"0.85931563",
"0.85584146",
"0.8483973",
"0.83962715",
"0.8340202",
"0.8340202",
"0.8340202",
"0.8292515",
"0.82672775",
"0.81334084",
"0.81334084",
"0.8076709",
"0.7736215",
"0.7632696",
"0.7541725",
"0.7511679",
"0.7510378",
"0.75102514",
"0.74861866",
"0.74576... | 0.7496113 | 19 |
Returns the modified board | def get_board(self):
return self._board.get_board() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_board(self):\n return copy.deepcopy(self.board)",
"def get_board(self):\n return self.board.copy()",
"def board(self):\n return copy.deepcopy(self._board)",
"def get_board(self) -> Tuple[Tuple[chr]]:\n # If we return the list, then the caller could modify the board,\n ... | [
"0.7892362",
"0.77313495",
"0.77217025",
"0.71888256",
"0.7169571",
"0.7100963",
"0.70776004",
"0.702484",
"0.6998541",
"0.69512707",
"0.6892022",
"0.68709606",
"0.68190193",
"0.681414",
"0.67837346",
"0.6763473",
"0.6762538",
"0.6758408",
"0.67419964",
"0.6720759",
"0.667477... | 0.65364766 | 32 |
Returns the state of the game of the JanggiGame object. Depending on the game state, it will return 'UNFINISHED', 'RED_WON', or 'BLUE_WON'. | def get_game_state(self):
return self._current_state | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_game_state(self):\n return self._game_status",
"def get_game_state(self):\n return self.game_state",
"def get_game_state(self):\r\n return self._game_state",
"def game_state(self):\n return self._game_state",
"def get_game_state(self):\n return self._game_state",
... | [
"0.7859136",
"0.7574257",
"0.74340075",
"0.7409152",
"0.7396259",
"0.7396259",
"0.7396259",
"0.72932476",
"0.72932476",
"0.7233707",
"0.69657916",
"0.6771893",
"0.67710197",
"0.6616355",
"0.65371597",
"0.6462404",
"0.6418556",
"0.6380044",
"0.629822",
"0.62753946",
"0.6242666... | 0.732088 | 7 |
Takes as a parameter a player (red or blue) and returns True if that player is in check, but return False otherwise. | def is_in_check(self, player):
# List of coords in board
col = ['a','b','c','d','e','f','g','h','i'] # the columns
a = []
for i in range(10):
a.append([j + str(i+1) for j in col])
# Flatten the list
board_coords = []
for sublist in a:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_a_player_in_check(self, color):\n\n current_player = color\n if current_player == 'red':\n opposing_player = 'blue'\n else:\n opposing_player = 'red'\n\n if self.can_checkmate(opposing_player):\n return self.get_general(current_player)\n\n ... | [
"0.79236925",
"0.7398487",
"0.72824985",
"0.72756344",
"0.7033824",
"0.66424614",
"0.6566459",
"0.64891684",
"0.64220923",
"0.6324632",
"0.6276745",
"0.625594",
"0.6253059",
"0.6247629",
"0.62069917",
"0.6168962",
"0.6150106",
"0.6135477",
"0.6122833",
"0.6112812",
"0.6101494... | 0.6679276 | 5 |
Returns the Piece object sitting in the pos of the board | def get_piece_type(self, pos):
piece = self.get_board()[self.ind(pos)[0]][self.ind(pos)[1]]
return piece | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_game_piece_object_at_position(self, position):\n\n column, row = self.transpose_position(position)\n\n return self.get_board()[int(row)][int(column)]",
"def get_piece(self, position):\n return self.board[position[0]][position[1]]",
"def get_piece(self, square):\n return self... | [
"0.8197641",
"0.79538995",
"0.7825521",
"0.7825521",
"0.76192605",
"0.7518913",
"0.74976397",
"0.73587805",
"0.71033704",
"0.7013367",
"0.7013367",
"0.7009093",
"0.69670683",
"0.689905",
"0.68621624",
"0.6834348",
"0.6766392",
"0.6760974",
"0.6722869",
"0.6645159",
"0.6597885... | 0.7186229 | 8 |
Takes two parameters, strings that represent the square to move from and the square to move to. If the square being moved from doesn't contain an opposing piece, the move is not legal, or if the game has already won, then it should return False. Otherwise, make the move, remove any captured piece, update the game state... | def make_move(self, cur_pos, new_pos):
print(cur_pos, new_pos)
# Automatically check if the new_pos is the same color piece
piece = self.get_piece_type(cur_pos)
# Check if cur_pos is None
if piece == None:
print("the... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move_piece(self, from_square, to_square):\n moving_piece = self.get_piece(from_square)\n if moving_piece is not None and moving_piece.player == self.current_player:\n self.set_piece(to_square, moving_piece)\n self.promotion_check(to_square, from_square, moving_piece)\n ... | [
"0.7655737",
"0.7623852",
"0.7501258",
"0.74465007",
"0.7432097",
"0.7288445",
"0.7230711",
"0.7222319",
"0.71864444",
"0.71783805",
"0.71758235",
"0.71665055",
"0.71586996",
"0.71384645",
"0.7130617",
"0.71106654",
"0.7063356",
"0.7027979",
"0.70070565",
"0.6989784",
"0.6983... | 0.66769207 | 41 |
Converts the string input to an easier index for the board | def ind(self, pos):
row = int(pos[1:]) - 1
column = self.letter_to_column(pos[0])
return row, column | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def str_to_tile_index(s, index_of_a = 0xe6, index_of_zero = 0xdb, special_cases = None):\n\n\tres = []\n\tfor c in s:\n\t\tindex = None\n\t\tif ord(c) >= ord('a') and ord(c) <= ord('z'):\n\t\t\tindex = ord(c) - ord('a') + index_of_a\n\t\telif ord(c) >= ord('A') and ord(c) <= ord('Z'):\n\t\t\tindex = ord(c) - ord('... | [
"0.6576328",
"0.6363488",
"0.624561",
"0.624561",
"0.6237214",
"0.62040347",
"0.6185074",
"0.61043257",
"0.606646",
"0.5939117",
"0.5930663",
"0.5908649",
"0.58882946",
"0.5851099",
"0.5829864",
"0.580793",
"0.5769647",
"0.57682794",
"0.57541066",
"0.57187545",
"0.5717817",
... | 0.0 | -1 |
Method to convert string letters of columns to int to index | def letter_to_column(self, pos):
column_dict = {}
column_dict['a'] = 0
column_dict['b'] = 1
column_dict['c'] = 2
column_dict['d'] = 3
column_dict['e'] = 4
column_dict['f'] = 5
column_dict['g'] = 6
column_dict['h'] = 7
column_dict['i'] = 8
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def toindex(col, row):\n a2z = 'ABCDEFGHIJLKMNOPQRSTUVWXYZ'\n\n total = 0\n mult = 0\n for char in col:\n total += (a2z.find(char) + (26 * mult))\n mult += 1\n\n return total, row - 1",
"def _index_to_column(i, column=''):\n\n # A dictionary of numbers to letters starting at 0, e.... | [
"0.6976945",
"0.6873612",
"0.680931",
"0.67332953",
"0.67033523",
"0.66989946",
"0.65949094",
"0.6431376",
"0.62918687",
"0.6244091",
"0.6221332",
"0.61669165",
"0.6154201",
"0.61530066",
"0.61059856",
"0.60690355",
"0.6052834",
"0.6016676",
"0.5995972",
"0.59907895",
"0.5941... | 0.59729916 | 22 |
Method to convert string letters of columns to int to index | def column_to_letter(self, pos):
column_dict = {}
column_dict[0] = 'a'
column_dict[1] = 'b'
column_dict[2] = 'c'
column_dict[3] = 'd'
column_dict[4] = 'e'
column_dict[5] = 'f'
column_dict[6] = 'g'
column_dict[7] = 'h'
column_dict[8] = 'i'
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def toindex(col, row):\n a2z = 'ABCDEFGHIJLKMNOPQRSTUVWXYZ'\n\n total = 0\n mult = 0\n for char in col:\n total += (a2z.find(char) + (26 * mult))\n mult += 1\n\n return total, row - 1",
"def _index_to_column(i, column=''):\n\n # A dictionary of numbers to letters starting at 0, e.... | [
"0.69773763",
"0.68732166",
"0.68112355",
"0.6735234",
"0.6705109",
"0.669631",
"0.65928155",
"0.6434589",
"0.62909186",
"0.6246335",
"0.62254184",
"0.6169324",
"0.61528987",
"0.615157",
"0.6108927",
"0.60706455",
"0.60536516",
"0.6016396",
"0.5995302",
"0.5989416",
"0.597138... | 0.54425776 | 55 |
Covert 'f([a,b,c,d,e,f]) to f(a,b,c,d,e,f) call. | def func_star(a_b):
return insideroutine(*a_b) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eval_f(f, xs):\n l = []\n for x in xs:\n l.append(f(x))\n return l",
"def f(*args):\n alist = [a() for a in args]\n print(alist)",
"def sequence(f, lst: list) -> list:\n ret = []\n for ele in lst:\n ret.append(f(ele))\n return ret",
"def eval_func_tuple(f_args):\n ... | [
"0.64417416",
"0.6194303",
"0.6032134",
"0.59193003",
"0.5899575",
"0.589807",
"0.58902675",
"0.5849441",
"0.5749209",
"0.57405674",
"0.57334536",
"0.57245374",
"0.5656731",
"0.56464416",
"0.56302327",
"0.5609536",
"0.5590731",
"0.55637425",
"0.55504274",
"0.55219024",
"0.550... | 0.0 | -1 |
Calculate the value of pi using a random generator. The random generator generate two values between 1 and 1 and calculates if they are inside of a circle with radius 1 inscribed in the square. The result is returned as an approx. of pi. | def calc_p(ran):
import random
from math import sqrt
p = None; hits = 0; misses = 0
for i in range(ran):
x = random.random() * 2 - 1
y = random.random() * 2 - 1
r = sqrt(x**2 + y**2)
if r <= 1:
hits += 1
p = 4 * hits / ran
return p | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def estimate_pi(sims):\n \n # counter to hold points lying inside the circle\n in_circle = 0\n \n for s in range(0,sims):\n \n x = np.random.rand()\n y = np.random.rand()\n \n if (x**2 + y**2) <= 1:\n in_circle += 1\n \n # The ratio of pts. ins... | [
"0.74176675",
"0.7202477",
"0.7179133",
"0.67010486",
"0.668326",
"0.66006446",
"0.6467354",
"0.6415425",
"0.6362446",
"0.62683564",
"0.62245226",
"0.62131464",
"0.6184186",
"0.6181681",
"0.6101566",
"0.6096848",
"0.6072919",
"0.6071029",
"0.60627145",
"0.6019927",
"0.5976569... | 0.5991947 | 20 |
Programa para realizar un diagrama de doble eje con las transacciones OP_RETURN acumuladas en cada mes comparadas con las totales de la blockchain de Bitcoin y la evolucion del precio del dolar estadounidense durante ese tiempo | def main(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cmd_calculation():",
"def main():\n\t\n\t# Inicializo algunas variables que utilizare despues\n\ti = 0\n\tcommits_totales = 0\n\tnombres_contribuidores = []\n\tnumero_commits = []\n\tacumula_contribuidores = []\n\tacumula_commits = []\n\t\n\t# Los datos que he parseado los he obtenido desde la web https://bi... | [
"0.60324055",
"0.5963619",
"0.58010584",
"0.5757816",
"0.57402194",
"0.5715608",
"0.57114327",
"0.5643373",
"0.562714",
"0.5624544",
"0.5597461",
"0.5596113",
"0.5591563",
"0.5589612",
"0.55728364",
"0.5535985",
"0.553396",
"0.55213356",
"0.5505578",
"0.5474051",
"0.5448077",... | 0.0 | -1 |
Method MUST return the SAME copy of the Content object each time Be sure to initiate any randomness in the __init__ function of the class, before returning it from here | def get_content(self) -> Content:
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clone_rand(self):",
"def getContent(self) -> object:\n ...",
"def __init__(self):\n self.content = dict()",
"def rand(self):\n raise NotImplementedError",
"def __init__(self):\n self.content = \"\"",
"def dummy_content():\n return os.urandom(1 * 1024 * 1024) # 1MB",
... | [
"0.6796832",
"0.61951834",
"0.60562557",
"0.5941559",
"0.5938283",
"0.5827374",
"0.5814455",
"0.5808163",
"0.579704",
"0.5717248",
"0.56987363",
"0.5663192",
"0.5629828",
"0.552759",
"0.54836583",
"0.5479959",
"0.5479959",
"0.546736",
"0.5439642",
"0.54374665",
"0.54196405",
... | 0.58078265 | 8 |
Function to display pretty version of our data | def data_prettified(self, instance):
# Convert the data to sorted, indented JSON
response = json.dumps(instance.data, sort_keys=True, indent=2)
# Truncate the data. Alter as needed
response = response
# Get the Pygments formatter
formatter = HtmlFormatter(style='colorf... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def PrettyPrint(self):\r\n print(self.data)\r\n return",
"def print_pretty(self, data):\n length = max(map(lambda x: len(x), data.keys()))\n print '+-------------------------------------+'\n print '| Company Name | Year | Month | Value |'\n print '+----------------------... | [
"0.7719173",
"0.7675689",
"0.75009155",
"0.73934764",
"0.7364615",
"0.7338962",
"0.7307983",
"0.7254877",
"0.7247562",
"0.71973693",
"0.71448267",
"0.701191",
"0.7006872",
"0.7006784",
"0.6964423",
"0.6919075",
"0.6915411",
"0.6909021",
"0.6883892",
"0.6865821",
"0.68612784",... | 0.6304845 | 68 |
Function to display pretty version of our data | def criteria_prettified(self, instance):
# Convert the data to sorted, indented JSON
response = json.dumps(instance.criteria, sort_keys=True, indent=2)
# Truncate the data. Alter as needed
response = response
# Get the Pygments formatter
formatter = HtmlFormatter(style... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def PrettyPrint(self):\r\n print(self.data)\r\n return",
"def print_pretty(self, data):\n length = max(map(lambda x: len(x), data.keys()))\n print '+-------------------------------------+'\n print '| Company Name | Year | Month | Value |'\n print '+----------------------... | [
"0.77185553",
"0.7675632",
"0.750126",
"0.73926747",
"0.7364857",
"0.7339593",
"0.7308107",
"0.72555494",
"0.72478586",
"0.7197169",
"0.7144456",
"0.7011706",
"0.7006958",
"0.7006817",
"0.6964377",
"0.6919984",
"0.6915803",
"0.69093925",
"0.68848515",
"0.6866261",
"0.6861478"... | 0.0 | -1 |
Constructor for Port instances. | def __init__(self, env, name):
self.in_queue = simpy.Store(env)
self.out_queue = simpy.Store(env, capacity=1)
# indicates whether the port is already connected to a link
self.is_free = True
self.name = name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, address: str, port: int) -> None:\n super().__init__()\n self.address = address\n self.port = port",
"def __init__(self, env, name, num_ports):\n self.env = env\n self.ports = [Port(self.env, \"{}-port{}\".format(name, i))\n for i in rang... | [
"0.76332444",
"0.74735856",
"0.7443325",
"0.742413",
"0.73209405",
"0.7252206",
"0.7206813",
"0.717169",
"0.71701837",
"0.71494883",
"0.70678425",
"0.7031187",
"0.70053107",
"0.70053107",
"0.70024794",
"0.6982665",
"0.6973641",
"0.69500995",
"0.6920169",
"0.6881882",
"0.68489... | 0.6252036 | 72 |
Create a new instance of class Link. | def __init__(
self, env,
port1, port2,
megabits_per_second, propagation_delay_us):
if megabits_per_second <= 0:
raise FT4FTTSimException("Mbps must be a positive number.")
if propagation_delay_us < 0:
raise FT4FTTSimException("Propagation delay... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, link):\n self.__link = link",
"def link(self):\n return Link(connection=self)",
"def newLinkAtom(self, **attrlinks):\n return LinkAtom(self, **attrlinks)",
"def link(self, link):\r\n return links.Link(self, link)",
"def clone(self) -> \"Link\":\n cls = self... | [
"0.71911746",
"0.7103806",
"0.70951915",
"0.70128417",
"0.6998912",
"0.6950566",
"0.6664468",
"0.64406437",
"0.63864386",
"0.6384914",
"0.63063693",
"0.61813426",
"0.61374193",
"0.6131095",
"0.6112448",
"0.60522026",
"0.6046845",
"0.6038728",
"0.5975803",
"0.5960274",
"0.5952... | 0.0 | -1 |
Gives the time in microseconds to transmit num_bytes on the link. | def transmission_time_us(self, num_bytes):
bits_to_transmit = num_bytes * 8
transmission_time_us = (bits_to_transmit / self.megabits_per_second)
return transmission_time_us | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def us(self):\n return 1000 * 1000 * self.read()",
"def _estimate_write_time(self, data):\n return (len(data.encode('utf-8'))/(self.byte_rate))*1.25\n #1.25 multiplier accounts for start & stop bits",
"def ms(self):\n # my clock uses seconds internally\n return 1000 * self.re... | [
"0.6720585",
"0.6504805",
"0.6378402",
"0.62854517",
"0.6226713",
"0.6151735",
"0.61439157",
"0.61234903",
"0.60965896",
"0.6089865",
"0.6087299",
"0.6076675",
"0.6055497",
"0.6042046",
"0.60022366",
"0.5985856",
"0.59717196",
"0.59255844",
"0.59157556",
"0.59102046",
"0.5861... | 0.8264343 | 0 |
Create a new instance of class _Sublink. | def __init__(
self, env, link,
transmitter_port, receiver_port):
self.env = env
self.link = link
self._transmitter_port = transmitter_port
self._receiver_port = receiver_port
env.process(self.run()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createSubLinko(linko, lowerBound=None, upperBound=None,\n commands=None):\n\n if lowerBound is None:\n lowerBound = 0\n else:\n lowerBound = max(0, lowerBound)\n\n if upperBound is None:\n upperBound = len(linko)-1\n\n else:\n upperBound = min(len(linko... | [
"0.6257967",
"0.6163073",
"0.60195",
"0.57882196",
"0.577464",
"0.574946",
"0.5686489",
"0.55936325",
"0.549292",
"0.54859895",
"0.5432537",
"0.5427302",
"0.54079264",
"0.53992283",
"0.5375226",
"0.5358826",
"0.5355751",
"0.5349792",
"0.534975",
"0.5316411",
"0.53084326",
"... | 0.0 | -1 |
The port that is at the transmitting end of the _Sublink. | def transmitter_port(self):
return self._transmitter_port | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_port(self):\n return self.port",
"def port(self) -> int:\n return self.proto.port",
"def get_port(self):\n return self.__port",
"def port(self) -> int:",
"def port(self):\n # This property is not 100% needed, but is included instead of making the raw variable public to p... | [
"0.7666643",
"0.7646722",
"0.76203775",
"0.7555813",
"0.7527526",
"0.7489178",
"0.74788153",
"0.74788153",
"0.74788153",
"0.74788153",
"0.74788153",
"0.74788153",
"0.7478317",
"0.7445367",
"0.74300957",
"0.74130577",
"0.73831666",
"0.7348526",
"0.7346532",
"0.7333242",
"0.733... | 0.0 | -1 |
The port that is at the receiving end of the _Sublink. | def receiver_port(self):
return self._receiver_port | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def port(self) -> int:\n return self.proto.port",
"def get_port(self):\n return self.port",
"def get_port(self):\n return self.__port",
"def port(self) -> int:",
"def get_port(self) -> int:\n return int(self.socket.getsockname()[1])",
"def port(self):\n return self._por... | [
"0.7565528",
"0.7532018",
"0.74659866",
"0.7439742",
"0.742285",
"0.73868966",
"0.73868966",
"0.73868966",
"0.73868966",
"0.73868966",
"0.73868966",
"0.7381384",
"0.73809",
"0.7347191",
"0.73221254",
"0.7295965",
"0.72778606",
"0.72594",
"0.7227357",
"0.7207438",
"0.7188952",... | 0.7643471 | 0 |
Get a message from the transmitter port and simulate its transmission. | def run(self):
while True:
get_request = self.transmitter_port.out_queue.get()
message = yield get_request
log.debug("{} transmission of {} started".format(self, message))
bytes_to_transmit = (ethernet.PREAMBLE_SIZE_BYTES +
etherne... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transmit(self, message):\n pass",
"def sendmessage(self):\n \n self.message.parentItem = self.rxtxcontroller.transmittable.rootItem\n self.message.can_id = self.idInput.toPlainText()\n self.message.dlc = self.lengthInput.value()\n self.message.cycle_time = self.cycle... | [
"0.684243",
"0.67363435",
"0.64805746",
"0.6397877",
"0.6275249",
"0.62701553",
"0.61841",
"0.612267",
"0.607932",
"0.6078788",
"0.60505307",
"0.6041035",
"0.60303885",
"0.59952426",
"0.59837866",
"0.5981079",
"0.595386",
"0.59508383",
"0.5949485",
"0.5944476",
"0.5925772",
... | 0.5619365 | 64 |
Constructor for NetworkDevice instances. | def __init__(self, env, name, num_ports):
self.env = env
self.ports = [Port(self.env, "{}-port{}".format(name, i))
for i in range(num_ports)]
self.name = name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, env, name):\n NetworkDevice.__init__(self, env, name, 1)\n self.env.process(self.listen_for_messages(self.echo))",
"def __init__(self, env, name, num_ports, forwarding_table=None):\n NetworkDevice.__init__(self, env, name, num_ports)\n env.process(self.listen_for_me... | [
"0.6851177",
"0.6748132",
"0.66309136",
"0.66309136",
"0.6500413",
"0.63843066",
"0.63698804",
"0.6369662",
"0.6225673",
"0.6225343",
"0.6225343",
"0.6225343",
"0.6225343",
"0.6225343",
"0.6225343",
"0.61941713",
"0.61874044",
"0.616988",
"0.6166115",
"0.6155921",
"0.61374366... | 0.0 | -1 |
Simpy process that calls callback when messages are received. | def listen_for_messages(self, callback):
# generate get requests for all input queues
requests = [port.in_queue.get() for port in self.ports]
while requests:
# helper variable for the asserts
queues_with_pending_requests = [req.resource for req in requests]
# ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle(self, message):\n for callback in self.callbacks:\n callback(message['data'])",
"def process(self, message, callback):\n\n\t\tif message.type == message_type.EMIT:\n\t\t\t# We are in the server, the message has just been built.\n\t\t\t# Forward it nearly \"as is\". Only the message t... | [
"0.6461456",
"0.6393571",
"0.63271964",
"0.63271964",
"0.6291915",
"0.6262493",
"0.6188397",
"0.6178309",
"0.61189246",
"0.61158496",
"0.61088336",
"0.60785425",
"0.60589385",
"0.60589385",
"0.6042948",
"0.59404564",
"0.59378827",
"0.5920575",
"0.5919739",
"0.5919469",
"0.588... | 0.5810423 | 22 |
Simpy process that transmits a given message through a given port. | def instruct_transmission(self, message, port):
log.debug("{} instructing transmission of {} on {}".format(
self, message, port))
if port not in self.ports:
raise FT4FTTSimException("{} is not a port of {}".format(
port, self))
log.debug("{} queued for tra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sendtoserial(self, module, msg):\n self.send(\"sendserial/{}/{}:{}\\n\".format(self.msg_id, module, msg))\n self.msg_id += 1",
"def main():\n\tports = glob.glob(\"/dev/tty.wchusbserial*\") + glob.glob(\"/dev/tty.usbserial*\") + glob.glob(\"COM3\") + glob.glob(\"COM4\")\n\tBAUDRATE = 9600\n\tcho... | [
"0.6341472",
"0.6293827",
"0.61935765",
"0.61768764",
"0.60845244",
"0.59997296",
"0.5982778",
"0.59600025",
"0.5941384",
"0.59384024",
"0.5926423",
"0.5847764",
"0.58273816",
"0.5824853",
"0.58207375",
"0.5782529",
"0.576689",
"0.5765747",
"0.57117426",
"0.5698292",
"0.56982... | 0.5942089 | 8 |
Returns a list of all the input queues of the NetworkDevice instance. | def input_queues(self):
return [port.in_queue for port in self.ports] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_queue_list(self):\n return self.manager.get_queue_list()",
"def queues(self):\r\n return queues.Queues(self)",
"def queues(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"queues\")",
"def _get_queues(self):\n return self.__queues",
"... | [
"0.7292679",
"0.6934699",
"0.69167936",
"0.66446567",
"0.66446567",
"0.66446567",
"0.66446567",
"0.66446567",
"0.66446567",
"0.66446567",
"0.66446567",
"0.66446567",
"0.66436195",
"0.6511804",
"0.6432993",
"0.63185084",
"0.604206",
"0.6019034",
"0.5928827",
"0.5894514",
"0.58... | 0.8002415 | 0 |
Creates a new EchoDevice instance. | def __init__(self, env, name):
NetworkDevice.__init__(self, env, name, 1)
self.env.process(self.listen_for_messages(self.echo)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_device(self, name: str, app_eui: str, app_key: str, dev_eui: str):\n return create_device(self.api_key, name, app_eui, app_key, dev_eui)",
"def create_device():\n sonyapilib.device.TIMEOUT = 0.1\n device = SonyDevice(\"test\", \"test\")\n device.api_version = 3\n dev... | [
"0.67282104",
"0.67042243",
"0.63540506",
"0.6162925",
"0.6115467",
"0.5974485",
"0.5958021",
"0.59126955",
"0.5904831",
"0.5904831",
"0.582459",
"0.5774012",
"0.574377",
"0.5706385",
"0.5654795",
"0.56512624",
"0.5632538",
"0.5628998",
"0.5586961",
"0.5574681",
"0.5540587",
... | 0.5755721 | 12 |
Transmits messages through port number 0 of self. | def echo(self, messages):
for msg in messages:
self.env.process(self.instruct_transmission(msg, self.ports[0])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transmit(self, msg):\r\n # send our message to the client\r\n self.conn.sendall(msg)",
"def sendmessage(self):\n \n self.message.parentItem = self.rxtxcontroller.transmittable.rootItem\n self.message.can_id = self.idInput.toPlainText()\n self.message.dlc = self.lengt... | [
"0.6586354",
"0.6306763",
"0.6275869",
"0.62235427",
"0.62213975",
"0.61291033",
"0.6056939",
"0.59652483",
"0.59083354",
"0.59018594",
"0.58479804",
"0.58443874",
"0.5816736",
"0.5814703",
"0.5814414",
"0.5814414",
"0.5814414",
"0.5767786",
"0.5765079",
"0.57547325",
"0.5745... | 0.0 | -1 |
Create a new MessageRecordingDevice instance. | def __init__(self, env, name, num_ports):
NetworkDevice.__init__(self, env, name, num_ports)
self.reception_records = {}
self.env.process(self.listen_for_messages(self.do_timestamp_messages)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_recording(self) -> None:\n # Clear the internal ring buffer.\n self._buffer.fill(0)\n\n # Start recording using sounddevice's InputStream.\n self._stream.start()",
"def __create_record(self, id, message_reference_beginning):\n\n instrument = self.get_random_instrument()\n\n me... | [
"0.5758916",
"0.5686636",
"0.5537721",
"0.5493648",
"0.54801685",
"0.5463428",
"0.53606737",
"0.5157371",
"0.51448524",
"0.5118914",
"0.5102212",
"0.5065266",
"0.5059805",
"0.50597054",
"0.5050642",
"0.5007147",
"0.5006307",
"0.4985408",
"0.4973321",
"0.49512675",
"0.49166542... | 0.45228213 | 80 |
Timestamp each message in messages with the current time. | def do_timestamp_messages(self, messages):
timestamp = self.env.now
self.reception_records[timestamp] = messages
log.debug("{} recorded {}".format(self, self.reception_records)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_timestamp(self):\n self._timestamp = datetime.datetime.now()",
"def _set_timestamp(self):\n d = datetime.now()\n self._time_stamp = \"{:>2} {} {} {:>2}:{:>02}\".format(\n d.day, MONTH_ABBREV[d.month], d.year, d.hour, d.minute)",
"def update_sent_at_timesta... | [
"0.57357347",
"0.56538224",
"0.55772907",
"0.5564249",
"0.5544044",
"0.55338705",
"0.5520455",
"0.55119085",
"0.5480451",
"0.5466076",
"0.545656",
"0.54557925",
"0.5449149",
"0.5431155",
"0.5430672",
"0.5411746",
"0.53955257",
"0.5393176",
"0.5375465",
"0.5375465",
"0.5371491... | 0.7175772 | 0 |
Return the messages so far received by self. | def recorded_messages(self):
messages = []
for time in sorted(self.reception_records):
messages.extend(self.reception_records[time])
return messages | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_messages(self):\n return self.messages_received",
"def get_messages(self):\n return self.messages_received",
"def get_messages(self):\n return self.messages_received",
"def get_received_messages(self):\n return self.received_messages",
"def receive_messages(self):\n ... | [
"0.88695073",
"0.88695073",
"0.88695073",
"0.8815797",
"0.8482073",
"0.80366856",
"0.80197936",
"0.80197936",
"0.79494613",
"0.78715163",
"0.78715163",
"0.78715163",
"0.78098845",
"0.76520985",
"0.75286716",
"0.7497776",
"0.73959994",
"0.733988",
"0.7331962",
"0.731863",
"0.7... | 0.0 | -1 |
Return list of instants of time when messages have been received. The list is sorted from earlier time instants to later time instants. | def recorded_timestamps(self):
return sorted(self.reception_records.keys()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def recorded_messages(self):\n messages = []\n for time in sorted(self.reception_records):\n messages.extend(self.reception_records[time])\n return messages",
"def get_times(self):\n times = []\n for i in range(1, len(self.events)):\n times.append(self.eve... | [
"0.684062",
"0.61729896",
"0.6143938",
"0.6120178",
"0.6120178",
"0.6120178",
"0.6105195",
"0.61050284",
"0.6102716",
"0.6013917",
"0.5986549",
"0.5985908",
"0.59154207",
"0.5880672",
"0.5832029",
"0.5814234",
"0.5798199",
"0.5797925",
"0.5794117",
"0.5742637",
"0.5725615",
... | 0.5795757 | 18 |
Load the transmission commands to execute once the run method is activated by simpy. | def load_transmission_commands(self, transmission_commands):
self.transmission_commands = transmission_commands
log.debug("{} loaded transmissions: {}".format(
self, self.transmission_commands)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def commands():\n pass",
"def commands():\n pass",
"def commands():\n pass",
"def commands():\n pass",
"def run_setup_commands(self):\n if not hasattr(self, 'commands') or not self.commands:\n return\n print('{GREEN}Running setup commands...{NC}'.format(**colors))\n ... | [
"0.61570454",
"0.61570454",
"0.61570454",
"0.61570454",
"0.61092925",
"0.60501635",
"0.6043742",
"0.5988766",
"0.57840395",
"0.5749445",
"0.57305175",
"0.5717177",
"0.57016313",
"0.56879026",
"0.5674538",
"0.5642886",
"0.5623862",
"0.5583021",
"0.5561773",
"0.5525386",
"0.552... | 0.6781366 | 0 |
Simpy process that executes previously loaded transmission commands. | def run(self):
for time in sorted(self.transmission_commands):
delay_before_next_tx_order = time - self.env.now
log.debug("{} waiting for next transmission time".format(self))
# wait until next transmission time
yield self.env.timeout(delay_before_next_tx_order)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _command_dispatcher(self):\n # sysex commands are assembled into this list for processing\n #checkingport = self.serial_port.com_port\n logstring(\"Starting Command Dispatcher\")\n sysex = []\n while True:\n if self._valid_target_exists:\n #log... | [
"0.6074242",
"0.6074194",
"0.6026074",
"0.6014388",
"0.59757674",
"0.59675294",
"0.5964339",
"0.5933806",
"0.59212637",
"0.59133595",
"0.58851624",
"0.5854616",
"0.58538175",
"0.58313733",
"0.5826945",
"0.5811035",
"0.576115",
"0.5749615",
"0.5723569",
"0.571908",
"0.5709516"... | 0.5676819 | 24 |
Returns a list of time instants when transmissions will be instructed. | def transmission_start_times(self):
return sorted(self.transmission_commands.keys()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_target_timestamps(self):\n times=[]\n curr = self.begin_ts\n while curr<=self.end_ts:\n times.append(curr)\n curr = curr + 24 * 60 * 60\n return times",
"def ensemble_times(self):\n return self['validtime'].values",
"def transit_times(self):\n ... | [
"0.6600924",
"0.64621645",
"0.6443462",
"0.64339167",
"0.61645526",
"0.6126809",
"0.60728866",
"0.60608023",
"0.6047479",
"0.6042055",
"0.60369664",
"0.60369664",
"0.60369664",
"0.6036148",
"0.60101277",
"0.60079336",
"0.59973717",
"0.59792835",
"0.5938966",
"0.5935055",
"0.5... | 0.65130126 | 1 |
Creates a new Switch instance. | def __init__(self, env, name, num_ports, forwarding_table=None):
NetworkDevice.__init__(self, env, name, num_ports)
env.process(self.listen_for_messages(self.forward_messages))
if forwarding_table is None:
self.forwarding_table = {}
else:
self.forwarding_table = f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_switch():\n connection = MagicMock()\n connection.address = 'addr'\n connection.port = 'port'\n connection.protocol.version = 0x04\n switch = Switch('00:00:00:00:00:00:00:01', connection)\n switch._enabled = True\n return switch",
"def _create_switch(kn... | [
"0.80681705",
"0.6859319",
"0.6448392",
"0.6421026",
"0.63343406",
"0.6104088",
"0.5923678",
"0.58337927",
"0.5742754",
"0.5739367",
"0.57389903",
"0.5723718",
"0.5708668",
"0.5675376",
"0.56334275",
"0.5611639",
"0.55722886",
"0.555142",
"0.5515055",
"0.54920065",
"0.5438675... | 0.0 | -1 |
Forward each message in 'message_list' through the appropriate port. Note that forwarding a message from one port to another port is implemented as creating a new message instance based on the message in the first port, and transmitting the new message instance on the second port. | def forward_messages(self, message_list):
def find_ports(destination):
"""
Return a list of the ports that according to the forwarding table
lead to 'destination'.
Arguments:
destination: an instance of class NetworkDevice or an iterable
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _forward(self, messages):\n assert isinstance(messages, (tuple, list))\n assert len(messages) > 0\n assert all(isinstance(message, Message.Implementation) for message in messages)\n assert all(message.community == messages[0].community for message in messages)\n assert all(me... | [
"0.6203733",
"0.5830506",
"0.56460434",
"0.5634888",
"0.55948746",
"0.5523897",
"0.55229384",
"0.5491743",
"0.5479526",
"0.5479526",
"0.5468768",
"0.5325395",
"0.5231763",
"0.5212095",
"0.5202612",
"0.51999635",
"0.51933783",
"0.51795065",
"0.51346564",
"0.5112899",
"0.509607... | 0.8666615 | 0 |
Return a list of the ports that according to the forwarding table lead to 'destination'. | def find_ports(destination):
output_ports = set()
if isinstance(destination, collections.Iterable):
for device in destination:
# ports leading to device
ports_towards_device = self.forwarding_table.get(
device, self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _GetPorts(self):\n ports = []\n for start, end in self.term.destination_port:\n if start == end:\n ports.append(str(start))\n else:\n ports.append('%d-%d' % (start, end))\n return ports",
"def get_log_forwarding_destinations(self) -> dict:\n uri = f\"{self.uri}/log-for... | [
"0.68636054",
"0.63937044",
"0.6293385",
"0.61560774",
"0.6080188",
"0.60246485",
"0.602398",
"0.59798646",
"0.59217554",
"0.59217554",
"0.5894943",
"0.5894943",
"0.5879433",
"0.58708215",
"0.5780149",
"0.5772737",
"0.5771177",
"0.5760051",
"0.57555175",
"0.5754745",
"0.57275... | 0.8411196 | 0 |
Create an instance of Message. | def __init__(
self, env, source, destination, size_bytes, message_type,
data=None):
if not isinstance(size_bytes, int):
raise FT4FTTSimException("Message size must be integer")
if not (ethernet.MIN_FRAME_SIZE_BYTES <= size_bytes <=
ethernet.MAX_FRAME_S... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createMessage( self, *args, **kw ):\n return MailMessage( *args, **kw )",
"def Message(self, *args, **kwargs):\n return Message(self, *args, **kwargs)",
"def message(self, *args, **kwargs) -> Message:\n return Message(self.handle, *args, **kwargs)",
"def new_message(self, body=''):\r... | [
"0.84884113",
"0.8175667",
"0.79955214",
"0.7640678",
"0.7473492",
"0.72302175",
"0.7222123",
"0.71496403",
"0.71381205",
"0.712775",
"0.7072882",
"0.69774204",
"0.6921473",
"0.690925",
"0.68973404",
"0.68225324",
"0.6820419",
"0.67508817",
"0.6748958",
"0.6748958",
"0.674895... | 0.6519352 | 45 |
Integer that uniquely identifies the Message instance. | def identifier(self):
return self._identifier | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def msg_id(self):\n return struct.unpack('<H', self.pkt.payload[0:2])[0]",
"def message_id(self) -> int:\n enforce(self.is_set(\"message_id\"), \"message_id is not set.\")\n return cast(int, self.get(\"message_id\"))",
"def getMessageID(self):\n return self._payload[1]",
"def _gen... | [
"0.76075435",
"0.7545699",
"0.73668766",
"0.7294178",
"0.7286209",
"0.70943856",
"0.68959796",
"0.6863287",
"0.6861981",
"0.6852783",
"0.6852783",
"0.6852783",
"0.6852783",
"0.6852783",
"0.6852783",
"0.6852783",
"0.6852783",
"0.6852783",
"0.6852783",
"0.6852783",
"0.6852783",... | 0.0 | -1 |
Creates a new message instance using template_message as a template. | def from_message(cls, template_message):
new_equivalent_message = cls(
template_message.env,
template_message.source,
template_message.destination,
template_message.size_bytes,
template_message.message_type,
template_message.data)
r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_message(filename):\n\n with open(filename, 'r', encoding='utf-8') as template_file:\n template_file_contents = template_file.read()\n return Template(template_file_contents)",
"def createMessage( self, *args, **kw ):\n return MailMessage( *args, **kw )",
"def create_message(message_... | [
"0.6601167",
"0.65768903",
"0.6510156",
"0.62768304",
"0.6161473",
"0.6139816",
"0.59907115",
"0.59879017",
"0.5969052",
"0.5905473",
"0.59045595",
"0.5868151",
"0.5855637",
"0.5845727",
"0.58385235",
"0.5831153",
"0.5827659",
"0.5786477",
"0.57841724",
"0.5783322",
"0.578185... | 0.7471443 | 0 |
Returns true if self and message are identical except for the message identifier. | def __eq__(self, message):
return (self.source == message.source and
self.destination == message.destination and
self.size_bytes == message.size_bytes and
self.message_type == message.message_type and
self.data == message.data) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __eq__(self, other):\n result = NotImplemented\n if isinstance(other, Message):\n result = False\n if self is other:\n result = True\n else:\n # does not compare _id\n if (self._message_length == other._message_length a... | [
"0.75409573",
"0.6845765",
"0.6833236",
"0.67646956",
"0.676177",
"0.67007315",
"0.6687098",
"0.6542909",
"0.6538792",
"0.6526526",
"0.6486344",
"0.64815634",
"0.6458272",
"0.6454662",
"0.6447595",
"0.6419478",
"0.63492614",
"0.6322484",
"0.6286339",
"0.6276497",
"0.6268068",... | 0.735989 | 1 |
Create a player in the dictionary with and fill | def create_player(dct, player_name, place):
dct.update({player_name: ['N/A'] * place}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\r\n self.players = {}",
"def create_player(self, players, player_no, start_tile):\n if player_no in players.keys():\n raise ValueError(f\"Invalid map layout. Can't create player no {player_no} as it already exists.\")\n players[player_no] = Player(player_no, st... | [
"0.71841913",
"0.7117534",
"0.6787139",
"0.6747371",
"0.67037123",
"0.66691554",
"0.6661246",
"0.665843",
"0.66209733",
"0.65938175",
"0.64562774",
"0.64398587",
"0.6433812",
"0.64123106",
"0.6350407",
"0.6346398",
"0.6294373",
"0.62786156",
"0.62754565",
"0.6242238",
"0.6237... | 0.80811304 | 0 |
update a player's rank based on where the place is | def update_player_rank(dct, player_name, place, rank):
dct.get(player_name)[place - 1] = rank | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_player_rank(self, player, rank, match):\n\n # if player isn't moving, do nothing\n if player.rank == rank:\n return\n\n # if player doesn't have a rank yet, make them last\n if player.rank is None:\n player.rank = self.player_set.count()\n\n # upd... | [
"0.78234625",
"0.74328",
"0.73013973",
"0.7031596",
"0.69860005",
"0.69297636",
"0.69227743",
"0.6718269",
"0.65675956",
"0.65450794",
"0.63905835",
"0.6374642",
"0.63725924",
"0.6286222",
"0.62859046",
"0.6284572",
"0.62633055",
"0.62573326",
"0.6210624",
"0.62010586",
"0.61... | 0.8145205 | 0 |
Calculates real fx vol | def calculate_real_vol(df: pd.DataFrame)->pd.DataFrame:
# Real FX Vol
# Creating a DataFrame with real exchange rate for each country
real_fx = df.loc[:, (slice(None), 'r')]
# Getting the returns of real exchange rate
real_rets = real_fx.pct_change()*100
real_rets.columns = real_rets.column... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vol(x):\r\n return pi*(topdia(x)/2000.)**2 * length (x)",
"def _fv(self):\n return self.beta * (self.x ** self.c)",
"def vol(self) -> float:\n return float(self.tsdf.pct_change().std() * np.sqrt(self.periods_in_a_year))",
"def _dvolume_dbsf(self):\n\n vol = ((self.I0 * self.V.omega *\n ... | [
"0.73070735",
"0.7055493",
"0.69172645",
"0.6573522",
"0.65009266",
"0.6455832",
"0.64117163",
"0.6403448",
"0.6331578",
"0.6297328",
"0.6286567",
"0.62574166",
"0.6218514",
"0.6216334",
"0.62065506",
"0.6197417",
"0.61916447",
"0.6146077",
"0.6138969",
"0.60833204",
"0.60826... | 0.6478381 | 5 |
Generates output for MATLAB | def matlab_generate(df: pd.DataFrame, file_name: str):
df_matlab = df.copy()
df_matlab.columns = df_matlab.columns.map('_'.join)
df_matlab.index = df_matlab.index.strftime("%Y%m%d")
(df_matlab.pct_change()*100).to_csv(data_path+file_name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def writeMatlabOutput(self, output, prettyname):\n self.writeHeaderOutput((\"%\",\"%\"), output, prettyname)\n for d in self.data:\n # now just print it out\n line = d.buildMatlabDeclaration(\"\", \"\", root=self.matlabRoot)\n if len(line) != 0:\n outpu... | [
"0.6261904",
"0.61863387",
"0.6012252",
"0.59941685",
"0.5992061",
"0.5971011",
"0.5931234",
"0.58379275",
"0.58114743",
"0.5741615",
"0.5732039",
"0.5726772",
"0.57029516",
"0.56981534",
"0.5697533",
"0.569699",
"0.56939423",
"0.56920123",
"0.5633407",
"0.5568645",
"0.556820... | 0.0 | -1 |
Computes cross entropy between predicted and true discrete distrubtions. | def cross_entropy(true, pred, axis=-1, epsilon=1e-7):
pred = ivy.clip(pred, epsilon, 1 - epsilon)
log_pred = ivy.log(pred)
# noinspection PyUnresolvedReferences
return -ivy.reduce_sum(log_pred * true, axis) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cross_entropy(y_observed, p):\n\n pass",
"def cross_entropy(self, true_values, predicted_values):\n\n testing_set_size = len(true_values)\n running_sum = 0\n for i in range(len(true_values)):\n true_set = true_values[i]\n predicted_set = predicted_values[i]\n ... | [
"0.7500701",
"0.73290604",
"0.7280353",
"0.72169656",
"0.71859753",
"0.7156666",
"0.7091561",
"0.70152426",
"0.6998785",
"0.6982236",
"0.6946835",
"0.68625927",
"0.6841047",
"0.68150157",
"0.67943674",
"0.67832506",
"0.6776295",
"0.67718947",
"0.6770149",
"0.67530984",
"0.674... | 0.7321498 | 2 |
Computes the binary cross entropy loss. | def binary_cross_entropy(true, pred, epsilon=1e-7):
pred = ivy.clip(pred, epsilon, 1-epsilon)
# noinspection PyTypeChecker
return -(ivy.log(pred) * true + ivy.log(1 - pred) * (1 - true)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cross_entropy_loss():\n return nn.CrossEntropyLoss()",
"def loss(params: hk.Params, batch, label) -> jnp.ndarray:\r\n logits = net.apply(params, batch)\r\n labels = jax.nn.one_hot(label, n_classes)\r\n\r\n # Cross Entropy Loss\r\n softmax_xent = -jnp.sum(labels * jax.nn.log_sof... | [
"0.7383736",
"0.7212885",
"0.72030777",
"0.71922994",
"0.71341836",
"0.7111369",
"0.7096483",
"0.7090471",
"0.70701796",
"0.7056353",
"0.7049108",
"0.7034045",
"0.70304507",
"0.70156217",
"0.7005296",
"0.69976836",
"0.69873434",
"0.69613475",
"0.69289887",
"0.6923281",
"0.692... | 0.6654386 | 68 |
Computes sparse cross entropy between logits and labels. | def sparse_cross_entropy(true, pred, axis=-1, epsilon=1e-7):
true = ivy.one_hot(true, pred.shape[axis])
return cross_entropy(true, pred, axis, epsilon) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sparse_softmax_cross_entropy_with_logits(\n labels=None,\n logits=None,\n name=None):\n _ensure_xent_args(\"sparse_softmax_cross_entropy_with_logits\", labels, logits)\n\n # TODO(pcmurray) Raise an error when the label is not an index in\n # [0, num_classes). Note: This could break users who call t... | [
"0.7383931",
"0.731593",
"0.7313389",
"0.7231131",
"0.71668744",
"0.7103112",
"0.70853496",
"0.70765847",
"0.7019666",
"0.69701236",
"0.6949585",
"0.69058555",
"0.68960786",
"0.68960786",
"0.6874639",
"0.68409586",
"0.68385947",
"0.67765355",
"0.67698383",
"0.67664945",
"0.67... | 0.75039977 | 0 |
Return the number of fixations in the item. | def fixation_count(self) -> int:
return len([fix for fix in self.fixations if not fix.excluded]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def total(self) -> int:\n return len(self.fixes)",
"def item_count(self):\n return self.items.shape[0]",
"def count(self, item):\n return _(self._.count(item))",
"def items_num(self):\n\t\treturn len(self.items)",
"def items_num(self):\n\t\treturn len(self.items)",
"def items_num(sel... | [
"0.7213083",
"0.6613063",
"0.6595034",
"0.6532938",
"0.6532938",
"0.6506132",
"0.6467765",
"0.645923",
"0.64033294",
"0.6388774",
"0.632877",
"0.6280365",
"0.623872",
"0.61082006",
"0.61007196",
"0.60832393",
"0.605388",
"0.6051676",
"0.6040764",
"0.6022371",
"0.600364",
"0... | 0.77495074 | 0 |
Event handler for when the "assign" button is clicked | def on_assign(self): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _save_clicked(self, info):\n\n assignment = self._validate(info)\n if assignment is None:\n return\n\n # Update the data in the database.\n try:\n get_permissions_manager().policy_manager.policy_storage.set_assignment(assignment.user_name, [r.name for r in assi... | [
"0.629694",
"0.61017966",
"0.60601336",
"0.5925632",
"0.59112716",
"0.58607006",
"0.58108014",
"0.57452774",
"0.5703086",
"0.5687298",
"0.56709224",
"0.55582875",
"0.55336756",
"0.5520792",
"0.5518935",
"0.54766655",
"0.5393926",
"0.53858465",
"0.5372325",
"0.5365118",
"0.534... | 0.65540296 | 0 |
Event handler for when the "unassign" button is clicked | def on_unassign(self): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_assign_unassign(self, **kwargs):\n\n return self.api_request(self._get_method_fullname(\"update_assign_unassign\"), kwargs)",
"def assignmentsCalced(self, message):\n self.assign_btn.Disable()",
"def unassign(self, assignment, created_by):\n assignee = assignment.assignee\n ... | [
"0.6539649",
"0.6224625",
"0.6205943",
"0.6197301",
"0.60103565",
"0.5933693",
"0.59179527",
"0.58602744",
"0.5758165",
"0.5743737",
"0.57365894",
"0.5708317",
"0.5708317",
"0.5708317",
"0.5708317",
"0.56715363",
"0.5670001",
"0.56364554",
"0.55899113",
"0.55891675",
"0.55556... | 0.75327337 | 0 |
Builds the file tree for overrides compaction | def _build_file_tree(self):
# Build file tree with packmode and weigth info (# of file in the packmode)
root = {"packmode": None, "weight": None, "children": {}}
for filepath, packmode in self.override_packmode_map.items():
node = root
for part in filepath:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _buildindex( self ):\n try:\n import ROOT as rt\n except:\n print \"Could not load ROOT\"\n sys.exit(-1)\n \n # sigh. this is a mess\n self.producers = [] # all producer names found in ROOT files\n self.datatypes = [] # all data types... | [
"0.5822903",
"0.57955813",
"0.57734984",
"0.556816",
"0.54924077",
"0.5468945",
"0.5466384",
"0.5444506",
"0.5417983",
"0.54117495",
"0.540151",
"0.53963",
"0.5385253",
"0.53663236",
"0.5315143",
"0.5312253",
"0.5294251",
"0.52787477",
"0.5272092",
"0.52637345",
"0.524155",
... | 0.71749103 | 0 |
Uses DFS to assign to directory the packmode with maximum weight The override format support assigning a whole directory to a packmode, and having exception in that directory This method assign the packmode with the most files to the directory, so that the least amount of files/directory needs to be specified in the "o... | def _dfs_assign(self, filetree):
stack = [filetree]
while stack:
node = stack.pop()
if isinstance(node, tuple) and node[0]["packmode"] is None:
# all children have been seen already, assing packmode
node = node[0] # unpack the actual node
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _build_file_tree(self):\n # Build file tree with packmode and weigth info (# of file in the packmode)\n root = {\"packmode\": None, \"weight\": None, \"children\": {}}\n for filepath, packmode in self.override_packmode_map.items():\n node = root\n for part in filepath... | [
"0.62167066",
"0.55113137",
"0.545679",
"0.5249099",
"0.52270174",
"0.52258456",
"0.5218894",
"0.5173524",
"0.5060165",
"0.50510776",
"0.5016965",
"0.49667448",
"0.49320337",
"0.4899114",
"0.4883986",
"0.48228544",
"0.48040769",
"0.47905743",
"0.47506174",
"0.47441763",
"0.47... | 0.5894984 | 1 |
Uses recursive DFS to write the overrides from a weigthed, assigned file tree | def _write_overrides(
self, node, parent=None, parent_packmode=None, path_parts=tuple(), root=None
):
if root is None:
root = node
if (parent is root) or (
parent_packmode and node["packmode"] != parent_packmode
):
self.overrides[str(PurePath(*path... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _mutate_file(self, node, visited = set([])):\n for ch in self._get_children(node):\n\n if ch not in visited:\n visited.add(ch)\n\n try:\n self._mutate_node(ch)\n except Exception as e:\n print(e)\n\n ... | [
"0.67543304",
"0.5652397",
"0.55918777",
"0.5476559",
"0.5439046",
"0.54237384",
"0.53918606",
"0.538221",
"0.5363778",
"0.5344074",
"0.52756155",
"0.521393",
"0.517851",
"0.51598054",
"0.5157991",
"0.5055687",
"0.5039144",
"0.50361437",
"0.5031006",
"0.49998572",
"0.49961793... | 0.61889166 | 1 |
Print a simple greeting to each user in the list. | def greet_user(names):
for name in names:
msg = f"Hello, {name.title()} !"
print(msg) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def greet_users(names):\n for name in names:\n msg = \"Hello, \" + name.title() + \"!\"\n print(msg)",
"def greet_users(names):\n for name in names:\n msg = \"Hello, \" + name.title() + \"!\"\n print(msg)",
"def greet_users(names):\n for name in names:\n print(f\"Hel... | [
"0.7735355",
"0.7735355",
"0.7734715",
"0.77266586",
"0.77149934",
"0.7699153",
"0.7699153",
"0.73098725",
"0.7258156",
"0.7245961",
"0.7140347",
"0.7128372",
"0.712475",
"0.70942545",
"0.70942545",
"0.7049544",
"0.7025611",
"0.69582665",
"0.6946257",
"0.68995595",
"0.6774867... | 0.7658193 | 7 |
Start a combat, make all NPCs to cast skills automatically. | def start_combat(self):
super(HonourAutoCombatHandler, self).start_combat()
# All characters auto cast skills.
for char in self.characters.values():
character = char["char"]
character.start_auto_combat_skill() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def StartCombat(self):\n\n print(\"------------------------------------\")\n self.fighter1.PrintInfo()\n self.fighter2.PrintInfo()\n print(\"------------------------------------\")\n self.combatInProgress = True\n while self.combatInProgress and self.currentTurn < self.max... | [
"0.68635476",
"0.61531",
"0.6022753",
"0.60088336",
"0.5843919",
"0.58394575",
"0.5778643",
"0.56064093",
"0.5535863",
"0.55134916",
"0.5509995",
"0.5499876",
"0.54166967",
"0.5389035",
"0.53655183",
"0.536523",
"0.53433776",
"0.53231376",
"0.5306996",
"0.52780104",
"0.527367... | 0.841464 | 0 |
Finish a combat. Send results to players, and kill all failed characters. | def finish(self):
for char in self.characters.values():
character = char["char"]
character.stop_auto_combat_skill()
super(HonourAutoCombatHandler, self).finish() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def leave_combat(self):\n self.__regen()",
"def endBattle(self):\n self.map.removeDead()\n self.cancelAttackMode()\n self.deselectUnit()",
"def endCompetition(self):\n self.robot_exit = True",
"def finish(self, npc, world):\n pass",
"def finishTurn(self):\n ... | [
"0.5964447",
"0.5951488",
"0.583827",
"0.58253044",
"0.57186526",
"0.569342",
"0.5643143",
"0.5618079",
"0.5599302",
"0.55874985",
"0.556114",
"0.5545428",
"0.5520197",
"0.5506429",
"0.5500326",
"0.5500326",
"0.5500326",
"0.5500326",
"0.54973876",
"0.5483571",
"0.5472781",
... | 0.7119523 | 0 |
to get the whole data in 'bus' | def getList(self):
nodeList = get_array(self.casenum, 'bus')
self.nodeList = nodeList
return nodeList | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_bus_details():\n\n\tbus_detail = db.session.query(Bus.bus_name == (Bus.bus_name)).one()\n\n \n\treturn bus_detail",
"def get_bus_list():\n\n\tbuses = db.session.query(Bus.bus_name).all()\n\n \n\treturn buses",
"def _read_data(self):",
"def readOneData(self):\n\t\tpass",
"def get_all(self):\n ... | [
"0.66622156",
"0.6451813",
"0.6422266",
"0.6291614",
"0.62907284",
"0.6256919",
"0.6247429",
"0.61632484",
"0.61528784",
"0.61516654",
"0.6148364",
"0.60508144",
"0.6022441",
"0.6019723",
"0.60150313",
"0.6006078",
"0.6003648",
"0.5983829",
"0.59709984",
"0.596881",
"0.594059... | 0.54014295 | 100 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.